Upload 202 files

a few minor updates

Documentation/NPC_Addon_Development_Guide_Updated.md

@@ -866,7 +866,7 @@ def auto_register(game_engine):
         # Create the weather oracle NPC definition
         weather_oracle_npc = {
             'id': 'weather_oracle_auto',
-            'name': '🌤️ Weather Oracle (Auto)',
+            'name': '🌤️ Weather Oracle (MCP)',
             'x': 300, 'y': 150,
             'char': '🌤️',
             'type': 'mcp',

app.py

@@ -1,126 +1,123 @@
-#!/usr/bin/env python3
-"""
-MMORPG Application - Refactored Clean Architecture
-Main application entry point using clean architecture principles
-"""
-
-import gradio as gr
-import asyncio
-import threading
-from typing import Optional
-
-# Import our clean architecture components
-from src.core.game_engine import GameEngine
-from src.facades.game_facade import GameFacade
-from src.ui.huggingface_ui import HuggingFaceUI
-from src.ui.interface_manager import InterfaceManager
-from src.mcp.mcp_tools import GradioMCPTools
-
-class MMORPGApplication:
-    """Main application class that orchestrates the MMORPG game."""
-    
-    def __init__(self):
-        """Initialize the application with all necessary components."""
-        # Initialize core game engine (singleton)
-        self.game_engine = GameEngine()
-        
-        # Initialize game facade for simplified operations
-        self.game_facade = GameFacade()
-          # Initialize UI components
-        self.ui = HuggingFaceUI(self.game_facade)
-        self.interface_manager = InterfaceManager(self.game_facade, self.ui)
-        
-        # Initialize MCP tools for AI agent integration
-        self.mcp_tools = GradioMCPTools(self.game_facade)
-        
-        # Gradio interface reference
-        self.gradio_interface: Optional[gr.Blocks] = None
-        
-        # Background tasks
-        self._cleanup_task = None
-        self._auto_refresh_task = None
-        
-    def create_gradio_interface(self) -> gr.Blocks:
-        """Create and configure the Gradio interface."""
-        # Use the InterfaceManager to create the complete interface with proper event handling
-        self.interface_manager._create_interface_with_events()
-        self.gradio_interface = self.interface_manager.interface
-        return self.gradio_interface
-    
-    def start_background_tasks(self):
-        """Start background tasks for game maintenance."""
-        
-        def cleanup_task():
-            """Background task for cleaning up inactive players."""
-            while True:
-                try:
-                    self.game_facade.cleanup_inactive_players()
-                    threading.Event().wait(30)  # Wait 30 seconds
-                except Exception as e:
-                    print(f"Error in cleanup task: {e}")
-                    threading.Event().wait(5)  # Wait before retry
-        
-        def auto_refresh_task():
-            """Background task for auto-refreshing game state."""
-            while True:
-                try:
-                    # Trigger refresh for active sessions
-                    # This would need session tracking for real implementation
-                    threading.Event().wait(2)  # Refresh every 2 seconds
-                except Exception as e:
-                    print(f"Error in auto-refresh task: {e}")
-                    threading.Event().wait(5)  # Wait before retry
-        
-        # Start cleanup task
-        self._cleanup_task = threading.Thread(target=cleanup_task, daemon=True)
-        self._cleanup_task.start()
-        
-        # Start auto-refresh task
-        self._auto_refresh_task = threading.Thread(target=auto_refresh_task, daemon=True)
-        self._auto_refresh_task.start()
-    
-    def run(self, share: bool = False, server_port: int = 7860):
-        """Run the MMORPG application."""
-        print("🎮 Starting MMORPG Application...")
-        print("🏗️  Initializing game engine...")
-          # Initialize game world and services
-        if not self.game_engine.start():
-            print("❌ Failed to start game engine")
-            return
-        
-        print("🎨 Creating user interface...")
-        
-        # Create Gradio interface
-        interface = self.create_gradio_interface()
-        
-        print("🔧 Starting background tasks...")
-        
-        # Start background maintenance tasks
-        self.start_background_tasks()
-        
-        print("🚀 Launching server...")
-        print(f"🌐 Server will be available at: http://localhost:{server_port}")
-        
-        if share:
-            print("🔗 Public URL will be generated...")
-        
-        # Launch the interface
-        interface.launch(
-            share=share,
-            debug=True,
-           # server_port=server_port,
-            mcp_server=True,  # Enable MCP server integration
-            show_error=True,
-            quiet=False
-        )
-
-def main():
-    """Main entry point for the application."""
-    # Create and run the application
-    app = MMORPGApplication()
-    # Run with default settings
-    # Change share=True to make it publicly accessible
-    app.run(share=True, server_port=7869)
-
-if __name__ == "__main__":
-    main()
+#!/usr/bin/env python3
+"""
+MMORPG Application - Refactored Clean Architecture
+Main application entry point using clean architecture principles
+"""
+
+import gradio as gr
+import asyncio
+import threading
+from typing import Optional
+
+# Import our clean architecture components
+from src.core.game_engine import GameEngine
+from src.facades.game_facade import GameFacade
+from src.ui.huggingface_ui import HuggingFaceUI
+from src.ui.improved_interface_manager import ImprovedInterfaceManager
+from src.mcp.mcp_tools import GradioMCPTools
+
+class MMORPGApplication:
+    """Main application class that orchestrates the MMORPG game."""
+    
+    def __init__(self):
+        """Initialize the application with all necessary components."""
+        # Initialize core game engine (singleton)
+        self.game_engine = GameEngine()
+        
+        # Initialize game facade for simplified operations
+        self.game_facade = GameFacade()        # Initialize UI components
+        self.ui = HuggingFaceUI(self.game_facade)
+        self.interface_manager = ImprovedInterfaceManager(self.game_facade, self.ui)
+        
+        # Initialize MCP tools for AI agent integration
+        self.mcp_tools = GradioMCPTools(self.game_facade)
+          # Gradio interface reference
+        self.gradio_interface: Optional[gr.Blocks] = None
+        
+        # Background tasks
+        self._cleanup_task = None
+        self._auto_refresh_task = None
+        
+    def create_gradio_interface(self) -> gr.Blocks:
+        """Create and configure the Gradio interface."""
+        # Use the ImprovedInterfaceManager to create the complete interface with proper event handling
+        self.gradio_interface = self.interface_manager.create_interface()
+        return self.gradio_interface
+    
+    def start_background_tasks(self):
+        """Start background tasks for game maintenance."""
+        
+        def cleanup_task():
+            """Background task for cleaning up inactive players."""
+            while True:
+                try:
+                    self.game_facade.cleanup_inactive_players()
+                    threading.Event().wait(30)  # Wait 30 seconds
+                except Exception as e:
+                    print(f"Error in cleanup task: {e}")
+                    threading.Event().wait(5)  # Wait before retry
+        
+        def auto_refresh_task():
+            """Background task for auto-refreshing game state."""
+            while True:
+                try:
+                    # Trigger refresh for active sessions
+                    # This would need session tracking for real implementation
+                    threading.Event().wait(2)  # Refresh every 2 seconds
+                except Exception as e:
+                    print(f"Error in auto-refresh task: {e}")
+                    threading.Event().wait(5)  # Wait before retry
+        
+        # Start cleanup task
+        self._cleanup_task = threading.Thread(target=cleanup_task, daemon=True)
+        self._cleanup_task.start()
+        
+        # Start auto-refresh task
+        self._auto_refresh_task = threading.Thread(target=auto_refresh_task, daemon=True)
+        self._auto_refresh_task.start()
+    
+    def run(self, share: bool = False, server_port: int = 7860):
+        """Run the MMORPG application."""
+        print("🎮 Starting MMORPG Application...")
+        print("🏗️  Initializing game engine...")
+          # Initialize game world and services
+        if not self.game_engine.start():
+            print("❌ Failed to start game engine")
+            return
+        
+        print("🎨 Creating user interface...")
+        
+        # Create Gradio interface
+        interface = self.create_gradio_interface()
+        
+        print("🔧 Starting background tasks...")
+        
+        # Start background maintenance tasks
+        self.start_background_tasks()
+        
+        print("🚀 Launching server...")
+        print(f"🌐 Server will be available at: http://localhost:{server_port}")
+        
+        if share:
+            print("🔗 Public URL will be generated...")
+        
+        # Launch the interface
+        interface.launch(
+            share=share,
+            debug=True,
+            server_port=server_port,
+            mcp_server=True,  # Enable MCP server integration
+            show_error=True,
+            quiet=False
+        )
+
+def main():
+    """Main entry point for the application."""
+    # Create and run the application
+    app = MMORPGApplication()
+    # Run with default settings
+    # Change share=True to make it publicly accessible
+    app.run(share=True, server_port=7869)
+
+if __name__ == "__main__":
+    main()

src/addons/duckduckgo_search_oracle_addon.py

@@ -65,7 +65,7 @@ class DuckDuckGoSearchOracleService(IDuckDuckGoSearchService, NPCAddon):
         return {
             'id': 'duckduckgo_search_oracle',
             'name': 'DuckDuckGo Search Oracle (MCP)',
-            'x': 450, 'y': 300,
+            'x': 250, 'y': 400,
             'char': '🦆',
             'type': 'mcp',
             'description': 'DuckDuckGo-powered web search information service'
@@ -408,8 +408,8 @@ def auto_register(game_engine):
         # Create the DuckDuckGo search oracle NPC definition
         duckduckgo_search_oracle_npc = {
             'id': 'duckduckgo_search_oracle_auto',
-            'name': '🦆 DuckDuckGo Search Oracle (Auto)',
-            'x': 450, 'y': 150,
+            'name': '🦆 DuckDuckGo Search Oracle (MCP)',
+            'x': 650, 'y': 150,
             'char': '🦆',
             'type': 'mcp',
             'personality': 'duckduckgo_search_oracle',

src/addons/fortune_teller_addon.py

@@ -44,7 +44,7 @@ class FortuneTellerAddon(NPCAddon):
         return {
             'id': 'fortune_teller',
             'name': 'Mystic Zelda',
-            'x': 125, 'y': 75,
+            'x': 225, 'y': 75,
             'char': '🔮',
             'type': 'addon',
             'description': 'Wise fortune teller who can glimpse into your future'
@@ -238,3 +238,39 @@ class FortuneTellerAddon(NPCAddon):
 
 # Auto-instantiate the addon for registration
 fortune_teller_addon = FortuneTellerAddon()
+
+
+def auto_register(game_engine):
+    """Auto-register the Fortune Teller addon with the game engine."""
+    try:
+        # Create addon instance
+        addon_instance = FortuneTellerAddon()
+        
+        # Get NPC config
+        npc_config = {
+            'id': 'fortune_teller',
+            'name': '🔮 Mystic Zelda',
+            'x': 150, 'y': 150,
+            'char': '🔮',
+            'type': 'mystic',
+            'personality': 'mystical'
+        }
+        
+        # Register NPC in world
+        npc_service = game_engine.get_npc_service()
+        npc_service.register_npc(npc_config['id'], npc_config)
+        
+        # Register addon for command handling
+        if not hasattr(game_engine.get_world(), 'addon_npcs'):
+            game_engine.get_world().addon_npcs = {}
+        game_engine.get_world().addon_npcs[npc_config['id']] = addon_instance
+        
+        # Call startup
+        addon_instance.on_startup()
+        
+        print(f"[FortuneTellerAddon] Auto-registered successfully as self-contained addon")
+        return True
+        
+    except Exception as e:
+        print(f"[FortuneTellerAddon] Error during auto-registration: {e}")
+        return False

src/addons/generic_mcp_server_addon.py

@@ -0,0 +1,122 @@
+import random
+import asyncio
+import gradio as gr
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+from contextlib import AsyncExitStack
+from ..interfaces.npc_addon import NPCAddon
+
+# Define approximate game world dimensions
+#TODO this seems wrong, should come fromt game config
+GAME_WIDTH = 800
+GAME_HEIGHT = 600
+
+class GenericMCPServerAddon(NPCAddon):
+    """
+    Generic MCP Server NPC-Addon instantiated per MCP-search result.
+    Expected config JSON keys:
+      - space_id: str         unique HF Space identifier
+      - title: str            display name for the addon
+      - author: str           author/organization of the space
+      - mcp_server_url: str   SSE endpoint for MCP integration
+      - description: str      optional descriptive text
+      - version: str          optional version tag
+    """
+    def __init__(self, config: dict):
+        # metadata from search result
+        self.name        = config.get("title", config.get("space_id", "MCP Server"))
+        self.description = config.get("description", f"MCP server NPC for {config.get('space_id', self.name)}")
+        self.version     = config.get("version", "auto")
+        self.author      = config.get("author", "unknown")
+        self.mcp_url     = config.get("mcp_server_url")
+        # initialize tool list
+        self.tools       = []
+        self.connected   = False
+        # random placement within game world
+        self.character   = "🔌"
+        x = random.randint(0, GAME_WIDTH)
+        y = random.randint(0, GAME_HEIGHT)
+        self.position    = (x, y)
+        self.npc_name    = self.name
+        # prepare event loop and session
+        try:
+            self.loop = asyncio.get_event_loop()
+        except RuntimeError:
+            self.loop = asyncio.new_event_loop()
+        self.session    = None
+        self.exit_stack = None
+        # register
+        super().__init__()
+
+    @property
+    def addon_id(self) -> str:
+        return self.name.lower().replace(" ", "_")
+
+    @property
+    def ui_tab_name(self) -> str:
+        return f"🔌 {self.name}"
+
+    @property
+    def npc_config(self) -> dict:
+        return {
+            'id':   self.addon_id,
+            'name': self.npc_name,
+            'x':    self.position[0],
+            'y':    self.position[1],
+            'char': self.character,
+            'type': 'mcp',
+            'description': self.description
+        }
+
+    def on_startup(self):
+        # connect on engine startup
+        self.connect_to_mcp()
+
+    def connect_to_mcp(self) -> str:
+        """Synchronously connect to MCP server via SSE"""
+        try:
+            return self.loop.run_until_complete(self._connect())
+        except Exception as e:
+            self.connected = False
+            return f"❌ Connection failed: {e}"
+
+    async def _connect(self) -> str:
+        # setup SSE client
+        if self.exit_stack:
+            await self.exit_stack.aclose()
+        self.exit_stack = AsyncExitStack()
+        rs, ws = await self.exit_stack.enter_async_context(sse_client(self.mcp_url))
+        self.session = await self.exit_stack.enter_async_context(ClientSession(rs, ws))
+        await self.session.initialize()
+        resp = await self.session.list_tools()
+        self.tools = resp.tools
+        self.connected = True
+        return f"✅ Connected to {self.name}, {len(self.tools)} tools available"
+
+    def handle_command(self, player_id: str, command: str) -> str:
+        # call first tool with full command
+        if not self.connected:
+            self.connect_to_mcp()
+        tool = self.tools[0] if self.tools else None
+        if not tool:
+            return "❌ No tools registered"
+        try:
+            params = { 'input': command }
+            result = self.loop.run_until_complete(self.session.call_tool(tool.name, params))
+            content = getattr(result, 'content', result)
+            if isinstance(content, list):
+                return "".join(getattr(item, 'text', str(item)) for item in content)
+            return getattr(content, 'text', str(content))
+        except Exception as e:
+            return f"❌ Error: {e}"
+
+    def get_interface(self) -> gr.Component:
+        with gr.Column() as interface:
+            gr.Markdown(f"## 🔌 {self.name}\nConnect and interact with this MCP server NPC.")
+            cmd_in = gr.Textbox(label="Command to send")
+            out = gr.Textbox(label="Output", lines=5)
+            btn = gr.Button("▶️ Send")
+            btn.click(lambda c: self.handle_command(None, c), inputs=[cmd_in], outputs=[out])
+        return interface
+
+# no manual registration needed; instantiating this class auto-registers the NPC-addon.

src/addons/huggingface_hub_addon.py

@@ -0,0 +1,674 @@
+"""
+Hugging Face Hub Oracle Add-on - MCP-powered Hugging Face Hub integration.
+"""
+
+import time
+import json
+import random
+import string
+import asyncio
+from typing import Dict, List, Optional
+import gradio as gr
+from abc import ABC, abstractmethod
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+from contextlib import AsyncExitStack
+
+from ..interfaces.npc_addon import NPCAddon
+
+
+class IHuggingFaceHubService(ABC):
+    """Interface for Hugging Face Hub service operations."""
+    
+    @abstractmethod
+    def search_models(self, query: str, task: str = None, library: str = None) -> str:
+        """Search for ML models."""
+        pass
+    
+    @abstractmethod
+    def search_datasets(self, query: str, author: str = None, tags: str = None) -> str:
+        """Search for datasets."""
+        pass
+    
+    @abstractmethod
+    def search_papers(self, query: str) -> str:
+        """Search for ML research papers."""
+        pass
+    
+    @abstractmethod
+    def search_spaces(self, query: str) -> str:
+        """Search for AI Apps/Spaces."""
+        pass
+    
+    @abstractmethod
+    def connect_to_mcp(self) -> str:
+        """Connect to Hugging Face Hub MCP server."""
+        pass
+
+
+class HuggingFaceHubOracleService(IHuggingFaceHubService, NPCAddon):
+    """Service for managing Hugging Face Hub Oracle MCP integration."""
+    
+    def __init__(self):
+        super().__init__()
+        self.connected = False
+        self.last_connection_attempt = 0
+        self.connection_cooldown = 30  # 30 seconds between connection attempts
+        self.server_url = "https://huggingface.co/mcp"
+        self.session = None
+        self.tools = []
+        self.exit_stack = None
+        self.hf_token = None  # Will need to be configured
+        # Set up event loop for async operations
+        try:
+            self.loop = asyncio.get_event_loop()
+        except RuntimeError:
+            self.loop = asyncio.new_event_loop()
+    
+    @property
+    def addon_id(self) -> str:
+        """Unique identifier for this add-on"""
+        return "huggingface_hub_oracle"
+    
+    @property
+    def addon_name(self) -> str:
+        """Display name for this add-on"""
+        return "Hugging Face Hub Oracle (MCP)"
+    
+    @property
+    def npc_config(self) -> Dict:
+        """NPC configuration for auto-placement in world"""
+        return {
+            'id': 'huggingface_hub_oracle',
+            'name': 'Hugging Face Hub Oracle (MCP)',
+            'x': 500, 'y': 150,
+            'char': '🤗',
+            'type': 'mcp',
+            'description': 'Hugging Face Hub-powered ML models, datasets, papers, and spaces search service'
+        }
+    
+    @property
+    def ui_tab_name(self) -> str:
+        """UI tab name for this addon"""
+        return "Hugging Face Hub Oracle"
+    
+    def get_interface(self) -> gr.Component:
+        """Return Gradio interface for this add-on"""
+        with gr.Column() as interface:
+            gr.Markdown("""
+            ## 🤗 Hugging Face Hub Oracle (MCP)
+            
+            *I commune with the Hugging Face Hub spirits through the mystical MCP protocol to bring you the best ML models, datasets, papers, and AI spaces!*
+            
+            **Ask me to find:**
+            - 🤖 **Models**: ML models with task and library filters
+            - 📊 **Datasets**: Datasets with author and tag filters  
+            - 📄 **Papers**: ML research papers via semantic search
+            - 🚀 **Spaces**: AI Apps and demos via semantic search
+            - 🔍 **Details**: Detailed information about specific models/datasets
+            
+            *Powered by Hugging Face Hub via Model Context Protocol (MCP)*
+            
+            **Note**: Requires HF token configuration for full functionality
+            """)
+            
+            # Connection status
+            connection_status = gr.HTML(
+                value=f"<div style='color: {'green' if self.connected else 'red'};'>{'🟢 Connected to Hugging Face Hub spirits' if self.connected else '🔴 Disconnected from HF Hub realm'}</div>"
+            )
+            
+            # HF Token configuration
+            with gr.Row():
+                hf_token_input = gr.Textbox(
+                    label="🔑 Hugging Face Token",
+                    placeholder="hf_...",
+                    type="password",
+                    scale=3
+                )
+                set_token_btn = gr.Button("🔑 Set Token", variant="secondary", scale=1)
+            
+            with gr.Tabs():
+                # Models Tab
+                with gr.TabItem("🤖 Models"):
+                    with gr.Row():
+                        model_query = gr.Textbox(
+                            label="Model Search Query",
+                            placeholder="e.g., text classification, image generation, language model",
+                            scale=2
+                        )
+                        model_task = gr.Textbox(
+                            label="Task Filter (optional)",
+                            placeholder="e.g., text-classification, image-to-text",
+                            scale=1
+                        )
+                        model_library = gr.Textbox(
+                            label="Library Filter (optional)", 
+                            placeholder="e.g., transformers, diffusers, pytorch",
+                            scale=1
+                        )
+                    search_models_btn = gr.Button("🤖 Search Models", variant="primary")
+                
+                # Datasets Tab
+                with gr.TabItem("📊 Datasets"):
+                    with gr.Row():
+                        dataset_query = gr.Textbox(
+                            label="Dataset Search Query",
+                            placeholder="e.g., image classification, natural language processing",
+                            scale=2
+                        )
+                        dataset_author = gr.Textbox(
+                            label="Author Filter (optional)",
+                            placeholder="e.g., huggingface, microsoft",
+                            scale=1
+                        )
+                        dataset_tags = gr.Textbox(
+                            label="Tags Filter (optional)",
+                            placeholder="e.g., computer-vision, nlp",
+                            scale=1
+                        )
+                    search_datasets_btn = gr.Button("📊 Search Datasets", variant="primary")
+                
+                # Papers Tab
+                with gr.TabItem("📄 Papers"):
+                    papers_query = gr.Textbox(
+                        label="Research Papers Search Query",
+                        placeholder="e.g., transformer architecture, diffusion models, reinforcement learning",
+                        scale=3
+                    )
+                    search_papers_btn = gr.Button("📄 Search Papers", variant="primary")
+                
+                # Spaces Tab
+                with gr.TabItem("🚀 Spaces"):
+                    spaces_query = gr.Textbox(
+                        label="AI Spaces Search Query", 
+                        placeholder="e.g., image generator, chatbot, text-to-speech",
+                        scale=3
+                    )
+                    search_spaces_btn = gr.Button("🚀 Search Spaces", variant="primary")
+            
+            # Results output
+            search_output = gr.Textbox(
+                label="🤗 Hugging Face Hub Wisdom",
+                lines=15,
+                interactive=False,
+                placeholder="Use the tabs above to search for models, datasets, papers, or spaces..."
+            )
+            
+            # Example queries
+            with gr.Row():
+                gr.Examples(
+                    examples=[
+                        ["GPT language models", "text-generation", "transformers"],
+                        ["image classification models", "image-classification", "pytorch"], 
+                        ["sentiment analysis", "text-classification", ""],
+                        ["stable diffusion", "text-to-image", "diffusers"],
+                        ["whisper speech recognition", "automatic-speech-recognition", ""]
+                    ],
+                    inputs=[model_query, model_task, model_library],
+                    label="🤖 Try These Model Searches"
+                )
+            
+            # Connection controls
+            with gr.Row():
+                connect_btn = gr.Button("🔗 Connect to HF Hub MCP", variant="secondary")
+                status_btn = gr.Button("📊 Check Status", variant="secondary")
+                tools_btn = gr.Button("🛠️ List Tools", variant="secondary")
+            
+            def handle_set_token(token: str):
+                if token.strip():
+                    self.hf_token = token.strip()
+                    return "✅ Hugging Face token configured successfully!"
+                return "❌ Please provide a valid HF token"
+            
+            def handle_search_models(query: str, task: str, library: str):
+                if not query.strip():
+                    return "❓ Please enter a model search query."
+                return self.search_models(query, task if task.strip() else None, library if library.strip() else None)
+            
+            def handle_search_datasets(query: str, author: str, tags: str):
+                if not query.strip():
+                    return "❓ Please enter a dataset search query."
+                return self.search_datasets(query, author if author.strip() else None, tags if tags.strip() else None)
+            
+            def handle_search_papers(query: str):
+                if not query.strip():
+                    return "❓ Please enter a papers search query."
+                return self.search_papers(query)
+            
+            def handle_search_spaces(query: str):
+                if not query.strip():
+                    return "❓ Please enter a spaces search query."
+                return self.search_spaces(query)
+            
+            def handle_connect():
+                result = self.connect_to_mcp()
+                # Update connection status
+                new_status = f"<div style='color: {'green' if self.connected else 'red'};'>{'🟢 Connected to Hugging Face Hub spirits' if self.connected else '🔴 Disconnected from HF Hub realm'}</div>"
+                return result, new_status
+            
+            def handle_status():
+                status = "🟢 Connected" if self.connected else "🔴 Disconnected"
+                token_status = "✅ Configured" if self.hf_token else "❌ Not set"
+                return f"🤗 **Hugging Face Hub Oracle Status**\n\nConnection: {status}\nHF Token: {token_status}\nLast update: {time.strftime('%H:%M')}\nAvailable: Models, Datasets, Papers, Spaces"
+            
+            def handle_list_tools():
+                if not self.connected:
+                    return "❌ Not connected to Hugging Face Hub MCP server. Please connect first."
+                if not self.tools:
+                    return "❌ No tools available."
+                
+                tool_info = "🛠️ **Available Hugging Face Hub Tools:**\n\n"
+                for tool in self.tools:
+                    tool_info += f"• **{tool.name}**: {tool.description}\n"
+                return tool_info
+            
+            # Wire up events
+            set_token_btn.click(
+                handle_set_token,
+                inputs=[hf_token_input],
+                outputs=[search_output]
+            )
+            
+            search_models_btn.click(
+                handle_search_models,
+                inputs=[model_query, model_task, model_library],
+                outputs=[search_output]
+            )
+            
+            search_datasets_btn.click(
+                handle_search_datasets,
+                inputs=[dataset_query, dataset_author, dataset_tags],
+                outputs=[search_output]
+            )
+            
+            search_papers_btn.click(
+                handle_search_papers,
+                inputs=[papers_query],
+                outputs=[search_output]
+            )
+            
+            search_spaces_btn.click(
+                handle_search_spaces,
+                inputs=[spaces_query],
+                outputs=[search_output]
+            )
+            
+            connect_btn.click(
+                handle_connect,
+                outputs=[search_output, connection_status]
+            )
+            
+            status_btn.click(
+                handle_status,
+                outputs=[search_output]
+            )
+            
+            tools_btn.click(
+                handle_list_tools,
+                outputs=[search_output]
+            )
+        
+        return interface
+    
+    def connect_to_mcp(self) -> str:
+        """Connect to Hugging Face Hub MCP server."""
+        current_time = time.time()
+        if current_time - self.last_connection_attempt < self.connection_cooldown:
+            return "⏳ Please wait before retrying connection..."
+        
+        self.last_connection_attempt = current_time
+        
+        if not self.hf_token:
+            return "❌ Please configure your Hugging Face token first using the token field above."
+        
+        try:
+            return self.loop.run_until_complete(self._connect())
+        except Exception as e:
+            self.connected = False
+            return f"❌ Connection failed: {str(e)}"
+    
+    async def _connect(self) -> str:
+        """Async connect to Hugging Face Hub MCP server."""
+        try:
+            # Clean up previous connection
+            if self.exit_stack:
+                await self.exit_stack.aclose()
+
+            self.exit_stack = AsyncExitStack()
+
+            # Connect to MCP server with authorization header
+            headers = {
+                "Authorization": f"Bearer {self.hf_token}"
+            }
+            
+            # Note: This is a simplified connection example
+            # The actual HF MCP server might use different connection methods
+            sse_transport = await self.exit_stack.enter_async_context(
+                sse_client(self.server_url, headers=headers)
+            )
+            read_stream, write_callable = sse_transport
+
+            self.session = await self.exit_stack.enter_async_context(
+                ClientSession(read_stream, write_callable)
+            )
+            await self.session.initialize()
+
+            # Get available tools
+            response = await self.session.list_tools()
+            self.tools = response.tools
+
+            self.connected = True
+            tool_names = [tool.name for tool in self.tools]
+            return f"✅ Connected to Hugging Face Hub MCP server!\nAvailable tools: {', '.join(tool_names)}"
+
+        except Exception as e:
+            self.connected = False
+            return f"❌ Connection failed: {str(e)}"
+    
+    def search_models(self, query: str, task: str = None, library: str = None) -> str:
+        """Search for ML models using Hugging Face Hub MCP server"""
+        if not self.connected:
+            # Try to auto-connect
+            connect_result = self.connect_to_mcp()
+            if not self.connected:
+                return f"❌ Failed to connect to Hugging Face Hub server. {connect_result}"
+        
+        try:
+            return self.loop.run_until_complete(self._search_models(query, task, library))
+        except Exception as e:
+            return f"❌ Error searching models: {str(e)}"
+    
+    async def _search_models(self, query: str, task: str = None, library: str = None) -> str:
+        """Async search models using HF Hub MCP."""
+        try:
+            # Find the model search tool
+            search_tool = next((tool for tool in self.tools if 'model' in tool.name.lower() and 'search' in tool.name.lower()), None)
+            
+            if not search_tool:
+                return "❌ Model search tool not found on server"
+
+            # Build parameters
+            params = {"query": query}
+            if task:
+                params["task"] = task
+            if library:
+                params["library"] = library
+
+            # Call the tool
+            result = await self.session.call_tool(search_tool.name, params)
+            
+            return self._format_search_results(result, "Models", query)
+
+        except Exception as e:
+            return f"❌ Failed to search models: {str(e)}"
+    
+    def search_datasets(self, query: str, author: str = None, tags: str = None) -> str:
+        """Search for datasets using Hugging Face Hub MCP server"""
+        if not self.connected:
+            connect_result = self.connect_to_mcp()
+            if not self.connected:
+                return f"❌ Failed to connect to Hugging Face Hub server. {connect_result}"
+        
+        try:
+            return self.loop.run_until_complete(self._search_datasets(query, author, tags))
+        except Exception as e:
+            return f"❌ Error searching datasets: {str(e)}"
+    
+    async def _search_datasets(self, query: str, author: str = None, tags: str = None) -> str:
+        """Async search datasets using HF Hub MCP."""
+        try:
+            # Find the dataset search tool
+            search_tool = next((tool for tool in self.tools if 'dataset' in tool.name.lower() and 'search' in tool.name.lower()), None)
+            
+            if not search_tool:
+                return "❌ Dataset search tool not found on server"
+
+            # Build parameters
+            params = {"query": query}
+            if author:
+                params["author"] = author
+            if tags:
+                params["tags"] = tags
+
+            # Call the tool
+            result = await self.session.call_tool(search_tool.name, params)
+            
+            return self._format_search_results(result, "Datasets", query)
+
+        except Exception as e:
+            return f"❌ Failed to search datasets: {str(e)}"
+    
+    def search_papers(self, query: str) -> str:
+        """Search for ML research papers using Hugging Face Hub MCP server"""
+        if not self.connected:
+            connect_result = self.connect_to_mcp()
+            if not self.connected:
+                return f"❌ Failed to connect to Hugging Face Hub server. {connect_result}"
+        
+        try:
+            return self.loop.run_until_complete(self._search_papers(query))
+        except Exception as e:
+            return f"❌ Error searching papers: {str(e)}"
+    
+    async def _search_papers(self, query: str) -> str:
+        """Async search papers using HF Hub MCP."""
+        try:
+            # Find the papers search tool
+            search_tool = next((tool for tool in self.tools if 'paper' in tool.name.lower() and 'search' in tool.name.lower()), None)
+            
+            if not search_tool:
+                return "❌ Papers search tool not found on server"
+
+            # Call the tool
+            params = {"query": query}
+            result = await self.session.call_tool(search_tool.name, params)
+            
+            return self._format_search_results(result, "Papers", query)
+
+        except Exception as e:
+            return f"❌ Failed to search papers: {str(e)}"
+    
+    def search_spaces(self, query: str) -> str:
+        """Search for AI Spaces using Hugging Face Hub MCP server"""
+        if not self.connected:
+            connect_result = self.connect_to_mcp()
+            if not self.connected:
+                return f"❌ Failed to connect to Hugging Face Hub server. {connect_result}"
+        
+        try:
+            return self.loop.run_until_complete(self._search_spaces(query))
+        except Exception as e:
+            return f"❌ Error searching spaces: {str(e)}"
+    
+    async def _search_spaces(self, query: str) -> str:
+        """Async search spaces using HF Hub MCP."""
+        try:
+            # Find the spaces search tool
+            search_tool = next((tool for tool in self.tools if 'space' in tool.name.lower() and 'search' in tool.name.lower()), None)
+            
+            if not search_tool:
+                return "❌ Spaces search tool not found on server"
+
+            # Call the tool
+            params = {"query": query}
+            result = await self.session.call_tool(search_tool.name, params)
+            
+            return self._format_search_results(result, "Spaces", query)
+
+        except Exception as e:
+            return f"❌ Failed to search spaces: {str(e)}"
+    
+    def _format_search_results(self, result, search_type: str, query: str) -> str:
+        """Format search results from MCP response."""
+        try:
+            # Extract content properly
+            content_text = ""
+            if hasattr(result, 'content') and result.content:
+                if isinstance(result.content, list):
+                    for content_item in result.content:
+                        if hasattr(content_item, 'text'):
+                            content_text += content_item.text
+                        elif hasattr(content_item, 'content'):
+                            content_text += str(content_item.content)
+                        else:
+                            content_text += str(content_item)
+                elif hasattr(result.content, 'text'):
+                    content_text = result.content.text
+                else:
+                    content_text = str(result.content)
+
+            if not content_text:
+                return f"❌ No {search_type.lower()} found for query: '{query}'"
+
+            # Try to parse as JSON for structured results
+            try:
+                parsed = json.loads(content_text)
+                if isinstance(parsed, list):
+                    formatted = f"🤗 **{search_type} Search Results for: '{query}'**\n\n"
+                    
+                    for i, item in enumerate(parsed[:5], 1):  # Limit to top 5 results
+                        if isinstance(item, dict):
+                            # Format based on search type
+                            if search_type == "Models":
+                                name = item.get('name', item.get('modelId', 'Unknown'))
+                                downloads = item.get('downloads', 'N/A')
+                                task = item.get('pipeline_tag', item.get('task', 'N/A'))
+                                formatted += f"**{i}. {name}**\n"
+                                formatted += f"📈 Downloads: {downloads}\n"
+                                formatted += f"🎯 Task: {task}\n"
+                                formatted += f"🔗 https://huggingface.co/{name}\n\n"
+                            
+                            elif search_type == "Datasets":
+                                name = item.get('name', item.get('id', 'Unknown'))
+                                downloads = item.get('downloads', 'N/A')
+                                size = item.get('size', 'N/A')
+                                formatted += f"**{i}. {name}**\n"
+                                formatted += f"📊 Downloads: {downloads}\n"
+                                formatted += f"💾 Size: {size}\n"
+                                formatted += f"🔗 https://huggingface.co/datasets/{name}\n\n"
+                            
+                            elif search_type == "Papers":
+                                title = item.get('title', 'Unknown')
+                                authors = item.get('authors', ['Unknown'])
+                                paper_id = item.get('id', '')
+                                formatted += f"**{i}. {title}**\n"
+                                formatted += f"👥 Authors: {', '.join(authors) if isinstance(authors, list) else authors}\n"
+                                formatted += f"🔗 https://huggingface.co/papers/{paper_id}\n\n"
+                            
+                            elif search_type == "Spaces":
+                                name = item.get('name', item.get('id', 'Unknown'))
+                                sdk = item.get('sdk', 'N/A')
+                                likes = item.get('likes', 'N/A')
+                                formatted += f"**{i}. {name}**\n"
+                                formatted += f"⚙️ SDK: {sdk}\n"
+                                formatted += f"❤️ Likes: {likes}\n"
+                                formatted += f"🔗 https://huggingface.co/spaces/{name}\n\n"
+                    
+                    formatted += f"⏰ Search completed: {time.strftime('%H:%M')}\n🤗 **Powered by Hugging Face Hub MCP**"
+                    return formatted
+            
+            except json.JSONDecodeError:
+                pass
+
+            # Fallback: return formatted raw content
+            formatted = f"🤗 **{search_type} Search Results for: '{query}'**\n\n"
+            formatted += f"```\n{content_text[:1500]}{'...' if len(content_text) > 1500 else ''}\n```\n\n"
+            formatted += f"⏰ Search completed: {time.strftime('%H:%M')}\n🤗 **Powered by Hugging Face Hub MCP**"
+            return formatted
+
+        except Exception as e:
+            return f"❌ Error formatting {search_type.lower()} results: {str(e)}"
+    
+    def handle_command(self, player_id: str, command: str) -> str:
+        """Handle Hugging Face Hub Oracle commands."""
+        parts = command.strip().split(' ', 2)
+        cmd = parts[0].lower()
+        
+        if cmd == "models" and len(parts) > 1:
+            query = parts[1]
+            return self.search_models(query)
+        elif cmd == "datasets" and len(parts) > 1:
+            query = parts[1]
+            return self.search_datasets(query)
+        elif cmd == "papers" and len(parts) > 1:
+            query = parts[1]
+            return self.search_papers(query)
+        elif cmd == "spaces" and len(parts) > 1:
+            query = parts[1]
+            return self.search_spaces(query)
+        elif cmd == "connect":
+            return self.connect_to_mcp()
+        elif cmd == "status":
+            status = "🟢 Connected" if self.connected else "🔴 Disconnected"
+            token_status = "✅ Configured" if self.hf_token else "❌ Not set"
+            return f"🤗 **Hugging Face Hub Oracle Status**\n\nConnection: {status}\nHF Token: {token_status}\nLast update: {time.strftime('%H:%M')}\nAvailable: Models, Datasets, Papers, Spaces"
+        elif cmd == "tools":
+            if not self.connected:
+                return "❌ Not connected to Hugging Face Hub MCP server. Use `connect` first."
+            if not self.tools:
+                return "❌ No tools available."
+            
+            tool_info = "🛠️ **Available Hugging Face Hub Tools:**\n\n"
+            for tool in self.tools:
+                tool_info += f"• **{tool.name}**: {tool.description}\n"
+            return tool_info
+        elif cmd == "help":
+            return """🤗 **Hugging Face Hub Oracle Commands:**
+
+**models** `<query>` - Search for ML models (e.g., 'models text classification')
+**datasets** `<query>` - Search for datasets (e.g., 'datasets image classification')
+**papers** `<query>` - Search for research papers (e.g., 'papers transformer')
+**spaces** `<query>` - Search for AI spaces/apps (e.g., 'spaces chatbot')
+**connect** - Connect to Hugging Face Hub MCP server
+**status** - Check connection and token status
+**tools** - List available MCP tools
+**help** - Show this help
+
+🤗 **Example Commands:**
+• models GPT language models
+• datasets computer vision
+• papers attention mechanism
+• spaces image generator
+
+🔑 **Note**: Configure HF token via UI for full functionality"""
+        else:
+            return "❓ Invalid command. Try: `models <query>`, `datasets <query>`, `papers <query>`, `spaces <query>`, `connect`, `status`, `tools`, or `help`"
+
+
+# Global Hugging Face Hub Oracle service instance
+huggingface_hub_oracle_service = HuggingFaceHubOracleService()
+
+
+def auto_register(game_engine):
+    """Auto-register the Hugging Face Hub Oracle addon with the game engine.
+    
+    This function makes the addon self-contained by handling its own registration.
+    """
+    try:
+        # Create the Hugging Face Hub oracle NPC definition
+        huggingface_hub_oracle_npc = {
+            'id': 'huggingface_hub_oracle_auto',
+            'name': '🤗 Hugging Face Hub Oracle (MCP)',
+            'x': 300, 'y': 150,
+            'char': '🤗',
+            'type': 'mcp',
+            'personality': 'huggingface_hub_oracle',
+            'description': 'Self-contained Hugging Face Hub MCP-powered ML models, datasets, papers, and spaces search service'
+        }
+        
+        # Register the NPC with the NPC service
+        npc_service = game_engine.get_npc_service()
+        npc_service.register_npc('huggingface_hub_oracle_auto', huggingface_hub_oracle_npc)
+        
+        # Register the addon for handling private message commands
+        world = game_engine.get_world()
+        if not hasattr(world, 'addon_npcs'):
+            world.addon_npcs = {}
+        world.addon_npcs['huggingface_hub_oracle_auto'] = huggingface_hub_oracle_service
+        
+        print("[HuggingFaceHubOracleAddon] Auto-registered successfully as self-contained addon")
+        return True
+        
+    except Exception as e:
+        print(f"[HuggingFaceHubOracleAddon] Error during auto-registration: {e}")
+        return False

src/addons/magic_shop_addon.py

@@ -75,7 +75,7 @@ class MagicShopAddon(NPCAddon):
         return {
             'id': 'magic_shop_keeper',
             'name': '🧙‍♀️ Mystical Mage Elara',
-            'x': 300, 'y': 150,  # Position in the game world
+            'x': 550, 'y': 450,  # Position in the game world
             'char': '🧙‍♀️',
             'type': 'magic_shop',
             'description': 'Wise mage selling powerful spells and magical items'
@@ -507,3 +507,39 @@ Based on your level, I recommend starting with healing magic!
 # Global instance - this triggers auto-registration!
 # Just like weather_oracle_service at the bottom of weather_oracle_addon.py
 magic_shop_addon = MagicShopAddon()
+
+
+def auto_register(game_engine):
+    """Auto-register the Magic Shop addon with the game engine."""
+    try:
+        # Create addon instance
+        addon_instance = MagicShopAddon()
+        
+        # Get NPC config
+        npc_config = {
+            'id': 'magic_shop',
+            'name': '🔮 Elara\'s Magic Shop',
+            'x': 350, 'y': 100,
+            'char': '🔮',
+            'type': 'magic_shop',
+            'personality': 'mystical'
+        }
+        
+        # Register NPC in world
+        npc_service = game_engine.get_npc_service()
+        npc_service.register_npc(npc_config['id'], npc_config)
+        
+        # Register addon for command handling
+        if not hasattr(game_engine.get_world(), 'addon_npcs'):
+            game_engine.get_world().addon_npcs = {}
+        game_engine.get_world().addon_npcs[npc_config['id']] = addon_instance
+        
+        # Call startup
+        addon_instance.on_startup()
+        
+        print(f"[MagicShopAddon] Auto-registered successfully as self-contained addon")
+        return True
+        
+    except Exception as e:
+        print(f"[MagicShopAddon] Error during auto-registration: {e}")
+        return False

src/addons/searchhf_addon.py

@@ -0,0 +1,369 @@
+"""
+SearchHF Oracle Addon - MCP-based Hugging Face search interface
+"""
+
+import asyncio
+import logging
+from typing import Dict, Any, Optional, List
+import gradio as gr
+import json
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+from contextlib import AsyncExitStack
+
+from ..interfaces.npc_addon import NPCAddon
+
+class SearchHFOracleAddon(NPCAddon):
+    """SearchHF Oracle Addon for searching Hugging Face using MCP."""
+    
+    def __init__(self):
+        # Initialize properties first
+        self.name = "SearchHF Oracle"
+        self.description = "Advanced Hugging Face search using specialized MCP server. Search and add any HF mcp to the game world."
+        self.version = "1.0.0"
+        self.author = "MMOP Team"
+        
+        # NPC characteristics
+        self.character = "🔍"
+        self.position = (200, 100)  # Position on the game map
+        self.npc_name = "SearchHF Oracle"
+        
+        # MCP Configuration
+        self.mcp_server_url = "https://chris4k-searchhfformcp.hf.space/gradio_api/mcp/sse"
+        self.connected = False
+        
+        # Available tools
+        self.available_tools = []
+        
+        # Logger
+        self.logger = logging.getLogger(__name__)
+        
+        # Initialize parent (which will auto-register)
+        super().__init__()
+        # MCP client components
+        try:
+            self.loop = asyncio.get_event_loop()
+        except RuntimeError:
+            self.loop = asyncio.new_event_loop()
+        self.session = None
+        self.exit_stack = None
+        self.tools = []
+    
+    @property
+    def addon_id(self) -> str:
+        """Unique identifier for this add-on"""
+        return "searchhf_oracle"
+    
+    @property
+    def addon_name(self) -> str:
+        """Display name for this add-on"""
+        return "SearchHF Oracle"
+    
+    @property
+    def npc_config(self) -> Dict:
+        """NPC configuration for auto-placement in world"""
+        return {
+            'id': 'searchhf_oracle',
+            'name': self.npc_name,
+            'x': self.position[0], 
+            'y': self.position[1],            'char': self.character,
+            'type': 'oracle',
+            'personality': 'searchhf',
+            'description': self.description
+        }
+    
+    @property
+    def ui_tab_name(self) -> str:
+        """UI tab name for this addon"""
+        return "SearchHF Oracle"
+    
+    def handle_command(self, player_id: str, command: str) -> str:
+        """Handle player commands via private messages"""
+        try:
+            if command.startswith("searchhf "):
+                query = command[9:].strip()
+                if not query:
+                    return "❌ Usage: searchhf <search_query>"
+                
+                result = asyncio.run(self._call_search_tool(query))
+                return result
+            
+            elif command == "searchhf_connect":
+                asyncio.run(self.connect_to_mcp())
+                if self.connected:
+                    return f"✅ Connected to SearchHF MCP server with {len(self.available_tools)} tools"
+                else:
+                    return "❌ Failed to connect to SearchHF MCP server"
+            
+            elif command == "searchhf_status":
+                status = "🟢 Connected" if self.connected else "🔴 Disconnected"
+                return f"SearchHF Oracle Status: {status} | Tools: {len(self.available_tools)}"
+            
+            elif command == "searchhf_tools":
+                if not self.available_tools:
+                    return "❌ No tools available. Use searchhf_connect first."
+                
+                tools_list = [f"- {tool.get('name', 'unknown')}: {tool.get('description', 'No description')}" 
+                             for tool in self.available_tools]
+                return f"🛠️ **Available SearchHF Tools:**\n" + "\n".join(tools_list)
+            
+            elif command == "searchhf_help":
+                return f"""
+                🔍 **SearchHF Oracle Help**
+                
+                **Commands:**
+                - searchhf <query> - Search Hugging Face
+                - searchhf_connect - Connect to MCP server
+                - searchhf_status - Check status
+                - searchhf_tools - List tools
+                - searchhf_help - Show help
+                  **Example:** searchhf BERT sentiment analysis                """
+            
+            return "❓ Unknown command. Use 'searchhf_help' for available commands."
+            
+        except Exception as e:
+            self.logger.error(f"[{self.name}] Error handling command {command}: {e}")
+            return f"❌ Error processing command: {str(e)}"
+    
+    def on_startup(self):
+        """Called when the addon is loaded during game startup"""
+        try:
+            # Connect to MCP server and fetch tools
+            result = self.connect_to_mcp()
+            self.logger.info(f"[{self.name}] Startup connection: {result}")
+         
+        except Exception as e:
+            self.logger.error(f"[{self.name}] Error during startup: {e}")
+            self.connected = False
+    
+    def connect_to_mcp(self) -> str:
+        """Synchronous connect to the SearchHF MCP server."""
+        try:
+            return self.loop.run_until_complete(self._connect())
+        except Exception as e:
+            self.connected = False
+            return f"❌ Connection failed: {e}"
+    
+    async def _connect(self) -> str:
+        """Async MCP connection using SSE."""
+        try:
+            if self.exit_stack:
+                await self.exit_stack.aclose()
+            self.exit_stack = AsyncExitStack()
+            transport = await self.exit_stack.enter_async_context(sse_client(self.mcp_server_url))
+            read_stream, write = transport
+            self.session = await self.exit_stack.enter_async_context(ClientSession(read_stream, write))
+            await self.session.initialize()
+            # list available MCP tools
+            response = await self.session.list_tools()
+            self.tools = response.tools
+            self.connected = True
+            names = [t.name for t in self.tools]
+            return f"✅ Connected with tools: {', '.join(names)}"
+        except Exception as e:
+            self.connected = False
+            return f"❌ Connection error: {e}"
+    
+    def get_interface(self) -> gr.Interface:
+        """Create the Gradio interface for the SearchHF addon."""
+        
+        def search_huggingface(query: str, search_type: str = "all") -> str:
+            """Search Hugging Face using the MCP server."""
+            if not query.strip():
+                return "❌ Please enter a search query"
+            
+            if not self.connected:
+                return "❌ Not connected to SearchHF MCP server. Use 'Connect' button first."
+            
+            try:
+                # Use the MCP service to call the search function
+                result = asyncio.run(self._call_search_tool(query, search_type))
+                return result
+                
+            except Exception as e:
+                error_msg = f"❌ Search error: {str(e)}"
+                self.logger.error(f"[{self.name}] {error_msg}")
+                return error_msg
+        
+        def connect_to_server() -> str:
+            """Connect to the MCP server."""
+            try:
+                result = asyncio.run(self.connect_to_mcp())
+                if self.connected:
+                    return f"✅ Connected to SearchHF MCP server\n🔧 Available tools: {len(self.available_tools)}"
+                else:
+                    return "❌ Failed to connect to SearchHF MCP server"
+            except Exception as e:
+                return f"❌ Connection error: {str(e)}"
+        
+        def get_status() -> str:
+            """Get current connection status."""
+            status = "🟢 Connected" if self.connected else "🔴 Disconnected"
+            return f"""
+            **SearchHF Oracle Status:**
+            - Connection: {status}
+            - MCP Server: {self.mcp_server_url}
+            - Available Tools: {len(self.available_tools)}
+            - Tools: {', '.join([tool.get('name', 'unknown') for tool in self.available_tools]) if self.available_tools else 'None'}
+            """
+        
+        def list_tools() -> str:
+            """List available MCP tools."""
+            if not self.available_tools:
+                return "❌ No tools available. Connect to server first."
+            
+            tools_info = ["**Available SearchHF Tools:**"]
+            for tool in self.available_tools:
+                name = tool.get('name', 'unknown')
+                description = tool.get('description', 'No description')
+                tools_info.append(f"- **{name}**: {description}")
+            
+            return "\n".join(tools_info)
+        
+        # Create the interface
+        with gr.Blocks(title=f"{self.character} {self.name}") as interface:
+            gr.Markdown(f"""
+            # {self.character} {self.name}
+            
+            Advanced Hugging Face search using specialized MCP integration.
+            Search models, datasets, papers, and spaces with enhanced capabilities.
+            
+            **MCP Server:** `{self.mcp_server_url}`
+            """)
+            
+            with gr.Tab("🔍 Search"):
+                with gr.Row():
+                    query_input = gr.Textbox(
+                        label="Search Query",
+                        placeholder="Enter your search query (e.g., 'BERT model', 'sentiment analysis', 'computer vision')",
+                        lines=2
+                    )
+                    search_type = gr.Dropdown(
+                        choices=["all", "models", "datasets", "papers", "spaces"],
+                        label="Search Type",
+                        value="all"
+                    )
+                
+                search_btn = gr.Button("🔍 Search Hugging Face", variant="primary")
+                
+                gr.Markdown("### Examples:")
+                example_queries = [
+                    "BERT sentiment analysis",
+                    "computer vision transformers",
+                    "text generation models",
+                    "image classification datasets",
+                    "machine learning papers 2024"
+                ]
+                
+                for example in example_queries:
+                    gr.Markdown(f"- `{example}`")
+                
+                result_output = gr.Textbox(
+                    label="Search Results",
+                    lines=10,
+                    max_lines=20
+                )
+                
+                search_btn.click(
+                    search_huggingface,
+                    inputs=[query_input, search_type],
+                    outputs=result_output
+                )
+            
+            with gr.Tab("🔧 Connection"):
+                with gr.Row():
+                    connect_btn = gr.Button("🔗 Connect to MCP Server", variant="secondary")
+                    status_btn = gr.Button("📊 Get Status")
+                    tools_btn = gr.Button("🛠️ List Tools")
+                
+                connection_output = gr.Textbox(
+                    label="Connection Status",
+                    lines=8
+                )
+                
+                connect_btn.click(connect_to_server, outputs=connection_output)
+                status_btn.click(get_status, outputs=connection_output)
+                tools_btn.click(list_tools, outputs=connection_output)
+            
+            with gr.Tab("ℹ️ Help"):
+                gr.Markdown(f"""
+                ## {self.character} SearchHF Oracle Help
+                
+                ### Chat Commands:
+                - `/searchhf <query>` - Search Hugging Face with your query
+                - `/searchhf_connect` - Connect to MCP server
+                - `/searchhf_status` - Check connection status
+                - `/searchhf_tools` - List available tools
+                - `/searchhf_help` - Show this help
+                
+                ### Features:
+                - 🔍 Advanced Hugging Face search
+                - 🤖 Models, datasets, papers, and spaces
+                - 🔗 MCP-based integration
+                - 📊 Real-time status monitoring
+                
+                ### MCP Integration:
+                The SearchHF Oracle uses a specialized MCP server for enhanced search capabilities:
+                ```
+                {self.mcp_server_url}
+                ```
+                
+                ### Search Types:
+                - **All**: Search across all Hugging Face content                - **Models**: Focus on ML models
+                - **Datasets**: Focus on datasets
+                - **Papers**: Focus on research papers
+                - **Spaces**: Focus on demo spaces
+                """)
+        
+        return interface
+    
+    async def _call_search_tool(self, query: str, search_type: str = "all") -> str:
+        """Call the search tool via MCP service and return the formatted result."""
+        if not self.connected:
+            conn = await self._connect()
+            if not self.connected:
+                return conn
+        # find search tool
+        tool = next((t for t in self.tools if 'search' in t.name.lower()), None)
+        if not tool:
+            return "❌ SearchHF tool not found on MCP server"
+        try:
+            params = {'query': query, 'search_type': search_type}
+            result = await self.session.call_tool(tool.name, params)
+            # extract text content
+            content = getattr(result, 'content', result)
+            text = ''
+            if isinstance(content, list):
+                for item in content:
+                    text += getattr(item, 'text', str(item))
+            else:
+                text = getattr(content, 'text', str(content))
+            return text or "❌ Empty response from SearchHF MCP"
+        except Exception as e:
+            return f"❌ Search error: {e}"
+# Auto-registration function for the game engine
+def auto_register(game_engine) -> bool:
+    """Auto-register the SearchHF Oracle addon with the game engine."""
+    try:
+        # Create addon instance (this will auto-register via NPCAddon)
+        addon = SearchHFOracleAddon()
+        
+        # Register NPC if needed
+        if addon.npc_config:
+            npc_service = game_engine.get_npc_service()
+            npc_service.register_npc(addon.npc_config['id'], addon.npc_config)
+        
+        # Add to addon NPCs for command handling  
+        if not hasattr(game_engine.get_world(), 'addon_npcs'):
+            game_engine.get_world().addon_npcs = {}
+        game_engine.get_world().addon_npcs[addon.addon_id] = addon
+        
+        # Call startup
+        addon.on_startup()
+        
+        print(f"[SearchHFOracleAddon] Auto-registered successfully as self-contained addon")
+        return True
+        
+    except Exception as e:
+        print(f"[SearchHFOracleAddon] Error during auto-registration: {e}")
+        return False

src/addons/simple_trader_addon.py

@@ -82,32 +82,7 @@ class SimpleTraderAddon(NPCAddon):
             'personality': 'trader',
             'description': 'A friendly trader selling useful items'
         }
-    
-    @classmethod
-    def auto_register(cls, game_engine):
-        """Automatically register this NPC with the game engine."""
-        try:
-            # Create addon instance
-            addon_instance = cls()
-            
-            # Get NPC config
-            npc_config = cls.get_npc_config()
-            
-            # Register NPC in world
-            npc_service = game_engine.get_npc_service()
-            npc_service.register_npc(npc_config['id'], npc_config)
-            
-            # Register addon for command handling
-            if not hasattr(game_engine.get_world(), 'addon_npcs'):
-                game_engine.get_world().addon_npcs = {}
-            game_engine.get_world().addon_npcs[npc_config['id']] = addon_instance
-            
-            print(f"[SimpleTrader] Auto-registered NPC '{npc_config['name']}' at position ({npc_config['x']}, {npc_config['y']})")
-            return True
-            
-        except Exception as e:
-            print(f"[SimpleTrader] Auto-registration failed: {e}")
-            return False
+      # ===== PRIVATE METHODS =====
     
     # ===== PRIVATE METHODS =====
     
@@ -181,6 +156,34 @@ simple_trader_addon = SimpleTraderAddon()
 
 
 # Auto-registration function that can be called from game engine
-def register_simple_trader(game_engine):
-    """Convenience function to register this addon."""
-    return SimpleTraderAddon.auto_register(game_engine)
+def auto_register(game_engine):
+    """Auto-register the Simple Trader addon with the game engine."""
+    try:
+        # Create addon instance
+        addon_instance = SimpleTraderAddon()
+        
+        # Get NPC config
+        npc_config = {
+            'id': 'simple_trader',
+            'name': '🛒 Simple Trader',
+            'x': 300, 'y': 300,
+            'char': '🛒',
+            'type': 'trader',
+            'personality': 'friendly'
+        }
+        
+        # Register NPC in world
+        npc_service = game_engine.get_npc_service()
+        npc_service.register_npc(npc_config['id'], npc_config)
+        
+        # Register addon for command handling
+        if not hasattr(game_engine.get_world(), 'addon_npcs'):
+            game_engine.get_world().addon_npcs = {}
+        game_engine.get_world().addon_npcs[npc_config['id']] = addon_instance
+        
+        print(f"[SimpleTrader] Auto-registered successfully as self-contained addon")
+        return True
+        
+    except Exception as e:
+        print(f"[SimpleTrader] Error during auto-registration: {e}")
+        return False

src/addons/weather_oracle_addon.py

@@ -354,8 +354,8 @@ def auto_register(game_engine):
         # Create the weather oracle NPC definition
         weather_oracle_npc = {
             'id': 'weather_oracle_auto',
-            'name': '🌤️ Weather Oracle (Auto)',
-            'x': 300, 'y': 150,
+            'name': '🌤️ Weather Oracle (MCCP)',
+            'x': 200, 'y': 350,
             'char': '🌤️',
             'type': 'mcp',
             'personality': 'weather_oracle',

src/core/game_engine.py

@@ -1,260 +1,257 @@
-"""
-Game Engine - Singleton pattern for centralized game management.
-"""
-
-import threading
-from typing import Dict, Any, Optional
-from ..interfaces.game_interfaces import IGameEngine, IGameWorld
-from ..core.world import GameWorld
-from ..services.player_service import PlayerService
-from ..services.chat_service import ChatService
-from ..services.npc_service import NPCService
-from ..services.mcp_service import MCPService
-from ..services.plugin_service import PluginService
-
-
-class GameEngine(IGameEngine):
-    """Singleton Game Engine managing all game services and state."""
-    
-    _instance = None
-    _lock = threading.Lock()
-    
-    def __new__(cls):
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super(GameEngine, cls).__new__(cls)
-        return cls._instance
-    
-    def __init__(self):
-        if hasattr(self, '_initialized'):
-            return
-        
-        self._initialized = True
-        self._running = False
-        self._services: Dict[str, Any] = {}
-        
-        # Initialize core components
-        self._game_world = GameWorld()
-          # Initialize services
-        self._player_service = PlayerService(self._game_world)
-        self._plugin_service = PluginService("plugins")
-        self._chat_service = ChatService(self._game_world, self._plugin_service)
-        self._npc_service = NPCService(self._game_world)
-        self._mcp_service = MCPService(self._player_service, self._chat_service)
-        
-        # Register services
-        self._services.update({
-            'player': self._player_service,
-            'chat': self._chat_service,
-            'npc': self._npc_service,
-            'mcp': self._mcp_service,
-            'plugin': self._plugin_service
-        })
-        
-        print("[GameEngine] Initialized with all services")
-    
-    def start(self) -> bool:
-        """Start the game engine."""
-        try:
-            if self._running:
-                print("[GameEngine] Already running")
-                return True
-            
-            # Set up plugin context
-            self._plugin_service.set_game_context({
-                'game_world': self._game_world,
-                'player_service': self._player_service,
-                'chat_service': self._chat_service,
-                'npc_service': self._npc_service,
-                'mcp_service': self._mcp_service
-            })
-            
-            # Load plugins
-            plugin_count = self._plugin_service.load_plugins()
-            print(f"[GameEngine] Loaded {plugin_count} plugins")
-            
-            # Initialize default world state
-            self._initialize_world()
-            
-            self._running = True
-            print("[GameEngine] Started successfully")
-            return True
-        
-        except Exception as e:
-            print(f"[GameEngine] Error starting: {e}")
-            return False
-    
-    def stop(self) -> bool:
-        """Stop the game engine."""
-        try:
-            if not self._running:
-                return True
-              # Unload all plugins
-            for plugin_id in list(self._plugin_service.get_loaded_plugins()):
-                self._plugin_service.unload_plugin(plugin_id)
-            
-            self._running = False
-            print("[GameEngine] Stopped successfully")
-            return True
-        
-        except Exception as e:
-            print(f"[GameEngine] Error stopping: {e}")
-            return False
-    
-    def get_world(self) -> IGameWorld:
-        """Get the game world instance."""
-        return self._game_world
-    
-    def register_service(self, service_name: str, service: Any) -> bool:
-        """Register a service with the engine."""
-        try:
-            self._services[service_name] = service
-            print(f"[GameEngine] Registered service: {service_name}")
-            return True
-        except Exception as e:
-            print(f"[GameEngine] Error registering service {service_name}: {e}")
-            return False
-    
-    def get_service(self, service_name: str) -> Optional[Any]:
-        """Get a registered service."""
-        return self._services.get(service_name)
-    
-    # Convenience methods for common operations
-    def get_player_service(self) -> PlayerService:
-        """Get player service."""
-        return self._player_service
-    
-    def get_chat_service(self) -> ChatService:
-        """Get chat service."""
-        return self._chat_service
-    
-    def get_npc_service(self) -> NPCService:
-        """Get NPC service."""
-        return self._npc_service
-    
-    def get_mcp_service(self) -> MCPService:
-        """Get MCP service."""
-        return self._mcp_service
-    
-    def get_plugin_service(self) -> PluginService:
-        """Get plugin service."""
-        return self._plugin_service
-    
-    def is_running(self) -> bool:
-        """Check if engine is running."""
-        return self._running
-
-    def _initialize_world(self):
-        """Initialize the world with default NPCs and setup."""
-        try:
-            # Add Donald NPC with new behavior
-            donald_npc = {
-                'id': 'donald',
-                'name': 'Donald the Trader',
-                'x': 400, 'y': 200,
-                'char': '💼',
-                'type': 'trader',
-                'personality': 'donald'
-            }
-            self._npc_service.register_npc('donald', donald_npc)
-              # Register addon NPCs
-            self._register_addon_npcs()
-            
-            # Initialize default sample plugin if in dev mode
-            self._plugin_service.create_sample_plugin()
-            
-            print("[GameEngine] World initialized with default content")
-        
-        except Exception as e:
-            print(f"[GameEngine] Error initializing world: {e}")
-
-    def _register_addon_npcs(self):
-        """Register NPC addons that can handle private message commands."""
-        try:
-            # Import the Read2Burn service
-            from ..addons.read2burn_addon import read2burn_service
-            
-            # Register the Read2Burn NPC first
-            read2burn_npc = {
-                'id': 'read2burn',
-                'name': '📮 Read2Burn Service',
-                'x': 100, 'y': 375,
-                'char': '📮',
-                'type': 'service',
-                'personality': 'read2burn',
-                'description': 'Secure message service - send private messages that auto-delete after reading'            }
-            self._npc_service.register_npc('read2burn', read2burn_npc)
-            
-            # Register the addon for handling private message commands
-            # The Read2BurnService already implements handle_command(player_id, command)
-            if not hasattr(self._game_world, 'addon_npcs'):
-                self._game_world.addon_npcs = {}
-            self._game_world.addon_npcs['read2burn'] = read2burn_service
-            
-            print("[GameEngine] Read2Burn addon registered successfully")
-            
-        except ImportError as e:
-            print(f"[GameEngine] Could not import Read2Burn service: {e}")
-        except Exception as e:
-            print(f"[GameEngine] Error registering Read2Burn addon: {e}")
-          # Auto-register self-contained addons
-        self._auto_register_addons()
-    
-    def _auto_register_addons(self):
-        """Automatically register all self-contained addons."""
-        auto_register_addons = [
-            ('weather_oracle_addon', 'auto_register'),
-            ('duckduckgo_search_oracle_addon', 'auto_register'),
-        ]
-        
-        for addon_module, auto_register_func in auto_register_addons:
-            try:
-                # Use importlib for cleaner imports
-                import importlib
-                full_module_name = f'src.addons.{addon_module}'
-                module = importlib.import_module(full_module_name)
-                auto_register = getattr(module, auto_register_func)
-                
-                # Call the auto-register function with the game engine
-                success = auto_register(self)
-                if success:
-                    print(f"[GameEngine] Auto-registered {addon_module} successfully")
-                else:
-                    print(f"[GameEngine] Failed to auto-register {addon_module}")
-                    
-            except ImportError as e:
-                print(f"[GameEngine] Could not import {addon_module}: {e}")
-            except Exception as e:
-                print(f"[GameEngine] Error auto-registering {addon_module}: {e}")
-    
-    def get_engine_status(self) -> Dict[str, Any]:
-        """Get comprehensive engine status."""
-        try:
-            all_players = self._player_service.get_all_players()
-            all_npcs = self._npc_service.get_all_npcs()
-            loaded_plugins = self._plugin_service.get_loaded_plugins()
-            recent_chat = self._chat_service.get_recent_messages(5)
-            
-            return {
-                'running': self._running,
-                'services': list(self._services.keys()),
-                'statistics': {
-                    'total_players': len(all_players),
-                    'active_players': len([p for p in all_players.values() if p.is_active()]),
-                    'total_npcs': len(all_npcs),
-                    'loaded_plugins': len(loaded_plugins),
-                    'recent_messages': len(recent_chat)
-                },
-                'loaded_plugins': loaded_plugins,
-                'world_state': self._game_world.get_world_state() if hasattr(self._game_world, 'get_world_state') else {}
-            }
-        
-        except Exception as e:
-            return {'error': str(e), 'running': self._running}
-
-
-# Convenience function to get the singleton instance
-def get_game_engine() -> GameEngine:
-    """Get the singleton game engine instance."""
-    return GameEngine()
+"""
+Game Engine - Singleton pattern for centralized game management.
+"""
+
+import threading
+from typing import Dict, Any, Optional
+from ..interfaces.game_interfaces import IGameEngine, IGameWorld
+from ..core.world import GameWorld
+from ..services.player_service import PlayerService
+from ..services.chat_service import ChatService
+from ..services.npc_service import NPCService
+from ..services.mcp_service import MCPService
+from ..services.plugin_service import PluginService
+
+
+class GameEngine(IGameEngine):
+    """Singleton Game Engine managing all game services and state."""
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(GameEngine, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if hasattr(self, '_initialized'):
+            return
+        
+        self._initialized = True
+        self._running = False
+        self._services: Dict[str, Any] = {}
+        
+        # Initialize core components
+        self._game_world = GameWorld()
+        
+        # Initialize services
+        self._player_service = PlayerService(self._game_world)
+        self._plugin_service = PluginService("plugins")
+        self._chat_service = ChatService(self._game_world, self._plugin_service)
+        self._npc_service = NPCService(self._game_world)
+        self._mcp_service = MCPService(self._player_service, self._chat_service)
+        
+        # Register services
+        self._services.update({
+            'player': self._player_service,
+            'chat': self._chat_service,
+            'npc': self._npc_service,
+            'mcp': self._mcp_service,
+            'plugin': self._plugin_service
+        })
+        
+        print("[GameEngine] Initialized with all services")
+    
+    def start(self) -> bool:
+        """Start the game engine."""
+        try:
+            if self._running:
+                print("[GameEngine] Already running")
+                return True
+            
+            # Set up plugin context
+            self._plugin_service.set_game_context({
+                'game_world': self._game_world,
+                'player_service': self._player_service,
+                'chat_service': self._chat_service,
+                'npc_service': self._npc_service,
+                'mcp_service': self._mcp_service
+            })
+            
+            # Load plugins
+            plugin_count = self._plugin_service.load_plugins()
+            print(f"[GameEngine] Loaded {plugin_count} plugins")
+            
+            # Initialize default world state
+            self._initialize_world()
+            
+            self._running = True
+            print("[GameEngine] Started successfully")
+            return True
+        
+        except Exception as e:
+            print(f"[GameEngine] Error starting: {e}")
+            return False
+    
+    def stop(self) -> bool:
+        """Stop the game engine."""
+        try:
+            if not self._running:
+                return True
+            
+            # Unload all plugins
+            for plugin_id in list(self._plugin_service.get_loaded_plugins()):
+                self._plugin_service.unload_plugin(plugin_id)
+            
+            self._running = False
+            print("[GameEngine] Stopped successfully")
+            return True
+        
+        except Exception as e:
+            print(f"[GameEngine] Error stopping: {e}")
+            return False
+    
+    def get_world(self) -> IGameWorld:
+        """Get the game world instance."""
+        return self._game_world
+    
+    def register_service(self, service_name: str, service: Any) -> bool:
+        """Register a service with the engine."""
+        try:
+            self._services[service_name] = service
+            print(f"[GameEngine] Registered service: {service_name}")
+            return True
+        except Exception as e:
+            print(f"[GameEngine] Error registering service {service_name}: {e}")
+            return False
+    
+    def get_service(self, service_name: str) -> Optional[Any]:
+        """Get a registered service."""
+        return self._services.get(service_name)
+    
+    # Convenience methods for common operations
+    def get_player_service(self) -> PlayerService:
+        """Get player service."""
+        return self._player_service
+    
+    def get_chat_service(self) -> ChatService:
+        """Get chat service."""
+        return self._chat_service
+    
+    def get_npc_service(self) -> NPCService:
+        """Get NPC service."""
+        return self._npc_service
+    
+    def get_mcp_service(self) -> MCPService:
+        """Get MCP service."""
+        return self._mcp_service
+    
+    def get_plugin_service(self) -> PluginService:
+        """Get plugin service."""
+        return self._plugin_service
+    
+    def is_running(self) -> bool:
+        """Check if engine is running."""
+        return self._running
+
+    def _initialize_world(self):
+        """Initialize the world with default NPCs and setup."""
+        try:
+            # Add Donald NPC with new behavior
+            donald_npc = {
+                'id': 'donald',
+                'name': 'Donald the Trader',
+                'x': 400, 'y': 200,
+                'char': '💼',
+                'type': 'trader',
+                'personality': 'donald'
+            }
+            self._npc_service.register_npc('donald', donald_npc)
+            
+            # Register addon NPCs
+            self._register_addon_npcs()
+              # Initialize default sample plugin if in dev mode
+            self._plugin_service.create_sample_plugin()
+            
+            print("[GameEngine] World initialized with default content")
+        except Exception as e:
+            print(f"[GameEngine] Error initializing world: {e}")
+
+    def _register_addon_npcs(self):
+        """Register NPC addons that can handle private message commands."""
+        # Auto-register self-contained addons
+        self._auto_register_addons()
+    def _auto_register_addons(self):
+        """Automatically discover and register all self-contained addons."""
+        import os
+        import importlib
+        
+        # Get the addons directory path
+        addons_dir = os.path.join(os.path.dirname(__file__), '..', 'addons')
+        addons_dir = os.path.abspath(addons_dir)
+        
+        if not os.path.exists(addons_dir):
+            print(f"[GameEngine] Addons directory not found: {addons_dir}")
+            return
+        
+        print(f"[GameEngine] Scanning for addons in: {addons_dir}")
+        
+        # Scan all Python files in addons directory
+        for filename in os.listdir(addons_dir):
+            if not filename.endswith('.py') or filename.startswith('__'):
+                continue
+                
+            addon_module_name = filename[:-3]  # Remove .py extension
+            
+            try:
+                # Import the module
+                full_module_name = f'src.addons.{addon_module_name}'
+                module = importlib.import_module(full_module_name)
+                
+                # Check if module has an auto_register function
+                if hasattr(module, 'auto_register'):
+                    auto_register_func = getattr(module, 'auto_register')
+                    
+                    # Verify it's a callable function
+                    if callable(auto_register_func):
+                        print(f"[GameEngine] Found auto_register function in {addon_module_name}")
+                        
+                        # Call the auto-register function with the game engine
+                        success = auto_register_func(self)
+                        if success:
+                            print(f"[GameEngine] Auto-registered {addon_module_name} successfully")
+                        else:
+                            print(f"[GameEngine] Failed to auto-register {addon_module_name}")
+                    else:
+                        print(f"[GameEngine] auto_register in {addon_module_name} is not callable")
+                else:
+                    print(f"[GameEngine] No auto_register function found in {addon_module_name} (skipping)")
+                    
+            except ImportError as e:
+                print(f"[GameEngine] Could not import addon {addon_module_name}: {e}")
+            except Exception as e:
+                print(f"[GameEngine] Error auto-registering {addon_module_name}: {e}")
+    
+    def get_engine_status(self) -> Dict[str, Any]:
+        """Get comprehensive engine status."""
+        try:
+            all_players = self._player_service.get_all_players()
+            all_npcs = self._npc_service.get_all_npcs()
+            loaded_plugins = self._plugin_service.get_loaded_plugins()
+            recent_chat = self._chat_service.get_recent_messages(5)
+            
+            return {
+                'running': self._running,
+                'services': list(self._services.keys()),
+                'statistics': {
+                    'total_players': len(all_players),
+                    'active_players': len([p for p in all_players.values() if p.is_active()]),
+                    'total_npcs': len(all_npcs),
+                    'loaded_plugins': len(loaded_plugins),
+                    'recent_messages': len(recent_chat)
+                },
+                'loaded_plugins': loaded_plugins,
+                'world_state': self._game_world.get_world_state() if hasattr(self._game_world, 'get_world_state') else {}
+            }
+        
+        except Exception as e:
+            return {'error': str(e), 'running': self._running}
+
+
+# Convenience function to get the singleton instance
+def get_game_engine() -> GameEngine:
+    """Get the singleton game engine instance."""
+    return GameEngine()

src/core/game_engine_fixed.py

@@ -0,0 +1,266 @@
+"""
+Game Engine - Singleton pattern for centralized game management.
+"""
+
+import threading
+from typing import Dict, Any, Optional
+from ..interfaces.game_interfaces import IGameEngine, IGameWorld
+from ..core.world import GameWorld
+from ..services.player_service import PlayerService
+from ..services.chat_service import ChatService
+from ..services.npc_service import NPCService
+from ..services.mcp_service import MCPService
+from ..services.plugin_service import PluginService
+
+
+class GameEngine(IGameEngine):
+    """Singleton Game Engine managing all game services and state."""
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(GameEngine, cls).__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if hasattr(self, '_initialized'):
+            return
+        
+        self._initialized = True
+        self._running = False
+        self._services: Dict[str, Any] = {}
+        
+        # Initialize core components
+        self._game_world = GameWorld()
+        
+        # Initialize services
+        self._player_service = PlayerService(self._game_world)
+        self._plugin_service = PluginService("plugins")
+        self._chat_service = ChatService(self._game_world, self._plugin_service)
+        self._npc_service = NPCService(self._game_world)
+        self._mcp_service = MCPService(self._player_service, self._chat_service)
+        
+        # Register services
+        self._services.update({
+            'player': self._player_service,
+            'chat': self._chat_service,
+            'npc': self._npc_service,
+            'mcp': self._mcp_service,
+            'plugin': self._plugin_service
+        })
+        
+        print("[GameEngine] Initialized with all services")
+    
+    def start(self) -> bool:
+        """Start the game engine."""
+        try:
+            if self._running:
+                print("[GameEngine] Already running")
+                return True
+            
+            # Set up plugin context
+            self._plugin_service.set_game_context({
+                'game_world': self._game_world,
+                'player_service': self._player_service,
+                'chat_service': self._chat_service,
+                'npc_service': self._npc_service,
+                'mcp_service': self._mcp_service
+            })
+            
+            # Load plugins
+            plugin_count = self._plugin_service.load_plugins()
+            print(f"[GameEngine] Loaded {plugin_count} plugins")
+            
+            # Initialize default world state
+            self._initialize_world()
+            
+            self._running = True
+            print("[GameEngine] Started successfully")
+            return True
+        
+        except Exception as e:
+            print(f"[GameEngine] Error starting: {e}")
+            return False
+    
+    def stop(self) -> bool:
+        """Stop the game engine."""
+        try:
+            if not self._running:
+                return True
+            
+            # Unload all plugins
+            for plugin_id in list(self._plugin_service.get_loaded_plugins()):
+                self._plugin_service.unload_plugin(plugin_id)
+            
+            self._running = False
+            print("[GameEngine] Stopped successfully")
+            return True
+        
+        except Exception as e:
+            print(f"[GameEngine] Error stopping: {e}")
+            return False
+    
+    def get_world(self) -> IGameWorld:
+        """Get the game world instance."""
+        return self._game_world
+    
+    def register_service(self, service_name: str, service: Any) -> bool:
+        """Register a service with the engine."""
+        try:
+            self._services[service_name] = service
+            print(f"[GameEngine] Registered service: {service_name}")
+            return True
+        except Exception as e:
+            print(f"[GameEngine] Error registering service {service_name}: {e}")
+            return False
+    
+    def get_service(self, service_name: str) -> Optional[Any]:
+        """Get a registered service."""
+        return self._services.get(service_name)
+    
+    # Convenience methods for common operations
+    def get_player_service(self) -> PlayerService:
+        """Get player service."""
+        return self._player_service
+    
+    def get_chat_service(self) -> ChatService:
+        """Get chat service."""
+        return self._chat_service
+    
+    def get_npc_service(self) -> NPCService:
+        """Get NPC service."""
+        return self._npc_service
+    
+    def get_mcp_service(self) -> MCPService:
+        """Get MCP service."""
+        return self._mcp_service
+    
+    def get_plugin_service(self) -> PluginService:
+        """Get plugin service."""
+        return self._plugin_service
+    
+    def is_running(self) -> bool:
+        """Check if engine is running."""
+        return self._running
+
+    def _initialize_world(self):
+        """Initialize the world with default NPCs and setup."""
+        try:
+            # Add Donald NPC with new behavior
+            donald_npc = {
+                'id': 'donald',
+                'name': 'Donald the Trader',
+                'x': 400, 'y': 200,
+                'char': '💼',
+                'type': 'trader',
+                'personality': 'donald'
+            }
+            self._npc_service.register_npc('donald', donald_npc)
+            
+            # Register addon NPCs
+            self._register_addon_npcs()
+            
+            # Initialize default sample plugin if in dev mode
+            self._plugin_service.create_sample_plugin()
+            
+            print("[GameEngine] World initialized with default content")
+        
+        except Exception as e:
+            print(f"[GameEngine] Error initializing world: {e}")
+
+    def _register_addon_npcs(self):
+        """Register NPC addons that can handle private message commands."""
+        try:
+            # Import the Read2Burn service
+            from ..addons.read2burn_addon import read2burn_service
+            
+            # Register the Read2Burn NPC first
+            read2burn_npc = {
+                'id': 'read2burn',
+                'name': '📮 Read2Burn Service',
+                'x': 100, 'y': 375,
+                'char': '📮',
+                'type': 'service',
+                'personality': 'read2burn',
+                'description': 'Secure message service - send private messages that auto-delete after reading'
+            }
+            self._npc_service.register_npc('read2burn', read2burn_npc)
+            
+            # Register the addon for handling private message commands
+            # The Read2BurnService already implements handle_command(player_id, command)
+            if not hasattr(self._game_world, 'addon_npcs'):
+                self._game_world.addon_npcs = {}
+            self._game_world.addon_npcs['read2burn'] = read2burn_service
+            
+            print("[GameEngine] Read2Burn addon registered successfully")
+            
+        except ImportError as e:
+            print(f"[GameEngine] Could not import Read2Burn service: {e}")
+        except Exception as e:
+            print(f"[GameEngine] Error registering Read2Burn addon: {e}")
+        
+        # Auto-register self-contained addons
+        self._auto_register_addons()
+    
+    def _auto_register_addons(self):
+        """Automatically register all self-contained addons."""
+        auto_register_addons = [
+            ('weather_oracle_addon', 'auto_register'),
+            ('duckduckgo_search_oracle_addon', 'auto_register'),
+            ('huggingface_hub_addon', 'auto_register'),
+        ]
+        
+        for addon_module, auto_register_func in auto_register_addons:
+            try:
+                # Use importlib for cleaner imports
+                import importlib
+                full_module_name = f'src.addons.{addon_module}'
+                module = importlib.import_module(full_module_name)
+                auto_register = getattr(module, auto_register_func)
+                
+                # Call the auto-register function with the game engine
+                success = auto_register(self)
+                if success:
+                    print(f"[GameEngine] Auto-registered {addon_module} successfully")
+                else:
+                    print(f"[GameEngine] Failed to auto-register {addon_module}")
+                    
+            except ImportError as e:
+                print(f"[GameEngine] Could not import {addon_module}: {e}")
+            except Exception as e:
+                print(f"[GameEngine] Error auto-registering {addon_module}: {e}")
+    
+    def get_engine_status(self) -> Dict[str, Any]:
+        """Get comprehensive engine status."""
+        try:
+            all_players = self._player_service.get_all_players()
+            all_npcs = self._npc_service.get_all_npcs()
+            loaded_plugins = self._plugin_service.get_loaded_plugins()
+            recent_chat = self._chat_service.get_recent_messages(5)
+            
+            return {
+                'running': self._running,
+                'services': list(self._services.keys()),
+                'statistics': {
+                    'total_players': len(all_players),
+                    'active_players': len([p for p in all_players.values() if p.is_active()]),
+                    'total_npcs': len(all_npcs),
+                    'loaded_plugins': len(loaded_plugins),
+                    'recent_messages': len(recent_chat)
+                },
+                'loaded_plugins': loaded_plugins,
+                'world_state': self._game_world.get_world_state() if hasattr(self._game_world, 'get_world_state') else {}
+            }
+        
+        except Exception as e:
+            return {'error': str(e), 'running': self._running}
+
+
+# Convenience function to get the singleton instance
+def get_game_engine() -> GameEngine:
+    """Get the singleton game engine instance."""
+    return GameEngine()

src/core/world.py

@@ -1,321 +1,321 @@
-"""
-Game World Model
-
-This module contains the GameWorld class that manages the game state,
-players, NPCs, and world events.
-"""
-
-import time
-import threading
-from typing import Dict, List, Any, Optional
-from dataclasses import asdict
-
-from .player import Player
-
-
-class GameWorld:
-    """
-    Central game world state manager.
-    
-    Manages players, NPCs, chat messages, and world events.
-    Thread-safe operations using RLock.
-    """
-    
-    def __init__(self):
-        self.players: Dict[str, Player] = {}
-        self.npcs: Dict[str, Dict] = self._initialize_npcs()        # Tree positions for collision detection (matching UI)
-        self.trees = [
-            {'x':150,'y':100}, {'x':300,'y':200}, {'x':350,'y':150},
-            {'x':200,'y':300}, {'x':100,'y':250}, {'x':400,'y':320}
-        ]
-        self.chat_messages: List[Dict] = []
-        self.world_events: List[Dict] = []
-        self.addon_npcs: Dict[str, Any] = {}  # NPCAddon instances
-        self._lock = threading.RLock()  # Thread-safe operations        # World configuration
-        self.max_players = 20
-        self.world_width = 800
-        self.world_height = 600
-        self.chat_history_limit = 50
-        
-        # Movement configuration (scale with world size)
-        self.movement_step = min(self.world_width, self.world_height) // 20  # 25px for 500x400 world
-        self.player_size = self.movement_step  # Player collision radius
-        self.tree_collision_radius = self.movement_step + 5  # Tree collision radius
-        
-        # Add initial system message
-        self.add_chat_message("System", "🎮 Game server started!")
-    
-    def _initialize_npcs(self) -> Dict[str, Dict]:
-        """Initialize the default NPCs in the world."""
-        return {
-            'donald': {
-                'id': 'donald',
-                'name': 'Donald the Trader',
-                'x': 250, 'y': 100,
-                'char': '💼',
-                'type': 'trader',
-                'personality': 'donald'
-            },
-            'read2burn_mailbox': {
-                'id': 'read2burn_mailbox',
-                'name': 'Secure Mailbox',
-                'x': 200, 'y': 150,
-                'char': '📮',
-                'type': 'addon'
-            },
-            'merchant': {
-                'id': 'merchant',
-                'name': 'Tom the Trader',
-                'x': 300, 'y': 200,
-                'char': '🏪',
-                'type': 'basic'            },
-            'example_merchant': {
-                'id': 'example_merchant',
-                'name': 'Example Merchant',
-                'x': 350, 'y': 250,
-                'char': '🏪',
-                'type': 'addon'
-            },
-            'scholar': {
-                'id': 'scholar',
-                'name': 'Professor Wise',
-                'x': 100, 'y': 100,
-                'char': '📚',
-                'type': 'learning',
-                'personality': 'wise_teacher'
-            },
-            'jester': {
-                'id': 'jester',
-                'name': 'Funny Pete',
-                'x': 400, 'y': 100,
-                'char': '🃏',
-                'type': 'entertainment',
-                'personality': 'comedian'
-            },
-            'warrior': {
-                'id': 'warrior',
-                'name': 'Captain Steel',
-                'x': 350, 'y': 350,
-                'char': '⚔️',
-                'type': 'combat',
-                'personality': 'tough_trainer'
-            },
-            'healer': {
-                'id': 'healer',
-                'name': 'Sister Grace',
-                'x': 50, 'y': 250,
-                'char': '💚',
-                'type': 'healing',
-                'personality': 'gentle_healer'
-            },
-            'wanderer': {
-                'id': 'wanderer',
-                'name': 'Roaming Rick',
-                'x': 200, 'y': 200,
-                'char': '🚶',
-                'type': 'moving',
-                'personality': 'traveler',
-                'movement': {
-                    'speed': 2,
-                    'direction_x': 1,
-                    'direction_y': 1,
-                    'last_move': time.time()
-                }
-            },
-            'sage': {
-                'id': 'sage',
-                'name': 'Ancient Sage',
-                'x': 450, 'y': 250,
-                'char': '🧙',
-                'type': 'magic',
-                'personality': 'mystical_sage'
-            }
-        }
-
-    # Player Management
-    def add_player(self, player: Player) -> bool:
-        """Add a player to the world."""
-        print(f"[GameWorld.add_player] Adding {player.name}")
-        with self._lock:
-            if len(self.players) >= self.max_players:
-                return False
-            self.players[player.id] = player
-            self.add_chat_message("System", f"🎮 {player.name} ({player.type}) joined the game!")
-            print(f"[GameWorld] Player {player.name} added. Total players: {len(self.players)}")
-            return True
-    
-    def remove_player(self, player_id: str) -> bool:
-        """Remove a player from the world."""
-        with self._lock:
-            if player_id in self.players:
-                player = self.players[player_id]
-                self.add_chat_message("System", f"👋 {player.name} left the game!")
-                del self.players[player_id]
-                return True
-            return False
-
-    def get_player(self, player_id: str) -> Optional[Player]:
-        """Get a player by ID."""
-        with self._lock:
-            return self.players.get(player_id)
-
-    def get_all_players(self) -> Dict[str, Player]:
-        """Get all players (thread-safe copy)."""
-        with self._lock:
-            return self.players.copy()
-
-    # Movement and Positioning
-    def move_player(self, player_id: str, direction: str) -> bool:
-        """Move a player in the specified direction."""
-        with self._lock:
-            if player_id not in self.players:
-                return False
-            player = self.players[player_id]
-            old_x, old_y = player.x, player.y            # Determine candidate new position without moving
-            new_x, new_y = player.x, player.y
-            if direction == "up":
-                new_y = max(0, player.y - self.movement_step)
-            elif direction == "down":
-                new_y = min(self.world_height, player.y + self.movement_step)
-            elif direction == "left":
-                new_x = max(0, player.x - self.movement_step)
-            elif direction == "right":
-                new_x = min(self.world_width, player.x + self.movement_step)
-            
-            # Check tree collision
-            for tree in self.trees:
-                if abs(new_x - tree['x']) < self.tree_collision_radius and abs(new_y - tree['y']) < self.tree_collision_radius:
-                    # Collision: do not move
-                    return False
-            # Perform movement
-            player.move_to(new_x, new_y)
-            # Award experience and handle level-up
-            if old_x != player.x or old_y != player.y:
-                player.experience += 1
-                if player.can_level_up():
-                    player.level_up()
-                    self.add_chat_message("System", f"🎉 {player.name} reached level {player.level}!")
-                # Check for NPC proximity events
-                self.check_npc_proximity(player_id)
-                return True
-            return False
-
-    def check_npc_proximity(self, player_id: str):
-        """Check if player is near any NPCs and trigger interactions."""
-        player = self.players.get(player_id)
-        if not player:
-            return
-
-        interaction_range = 50
-        nearby_npcs = []
-        
-        for npc_id, npc_data in self.npcs.items():
-            npc_x, npc_y = npc_data['x'], npc_data['y']
-            distance = ((player.x - npc_x) ** 2 + (player.y - npc_y) ** 2) ** 0.5
-            
-            if distance <= interaction_range:
-                nearby_npcs.append(npc_data['name'])
-        
-        if nearby_npcs:
-            npc_list = ", ".join(nearby_npcs)
-            self.add_world_event(f"🔍 {player.name} is near: {npc_list}")
-
-    # Chat and Communication
-    def add_chat_message(self, sender: str, message: str, message_type: str = "public", 
-                        target: str = None, sender_id: str = None):
-        """Add a chat message to the world."""
-        with self._lock:
-            chat_msg = {
-                'sender': sender,
-                'message': message,
-                'timestamp': time.strftime("%H:%M:%S"),
-                'id': len(self.chat_messages),
-                'type': message_type,
-                'target': target,
-                'sender_id': sender_id
-            }
-            self.chat_messages.append(chat_msg)
-            if len(self.chat_messages) > self.chat_history_limit:
-                self.chat_messages = self.chat_messages[-self.chat_history_limit:]
-
-    def get_chat_history(self, limit: int = None) -> List[Dict]:
-        """Get chat message history."""
-        with self._lock:
-            if limit:
-                return self.chat_messages[-limit:]
-            return self.chat_messages.copy()
-
-    def add_world_event(self, event: str):
-        """Add a world event."""
-        with self._lock:
-            event_data = {
-                'event': event,
-                'timestamp': time.strftime("%H:%M:%S"),
-                'id': len(self.world_events)
-            }
-            self.world_events.append(event_data)
-            if len(self.world_events) > 20:  # Keep last 20 events
-                self.world_events = self.world_events[-20:]
-
-    def get_world_events(self) -> List[Dict]:
-        """Get world events history."""
-        with self._lock:
-            return self.world_events.copy()
-
-    # NPC Management
-    def add_npc(self, npc_id: str, npc_data: Dict):
-        """Add an NPC to the world."""
-        with self._lock:
-            self.npcs[npc_id] = npc_data
-
-    def get_npc(self, npc_id: str) -> Optional[Dict]:
-        """Get NPC data by ID."""
-        with self._lock:
-            return self.npcs.get(npc_id)
-
-    def get_all_npcs(self) -> Dict[str, Dict]:
-        """Get all NPCs."""
-        with self._lock:
-            return self.npcs.copy()
-
-    # Utility Methods
-    def get_world_state(self) -> Dict:
-        """Get the complete world state for debugging/monitoring."""
-        with self._lock:
-            return {
-                'players': {pid: asdict(player) for pid, player in self.players.items()},
-                'npcs': self.npcs.copy(),
-                'recent_chat': self.chat_messages[-10:],
-                'recent_events': self.world_events[-5:],
-                'stats': {
-                    'total_players': len(self.players),
-                    'total_npcs': len(self.npcs),
-                    'total_messages': len(self.chat_messages),
-                    'total_events': len(self.world_events)
-                }
-            }
-
-    def cleanup_inactive_players(self, timeout_seconds: int = 86400):
-        """Remove players that have been inactive for too long."""
-        with self._lock:
-            inactive_players = [
-                player_id for player_id, player in self.players.items()
-                if not player.is_active(timeout_seconds)
-            ]
-            
-            for player_id in inactive_players:
-                self.remove_player(player_id)
-            
-            return len(inactive_players)
-    
-    def configure_world_dimensions(self, width: int, height: int):
-        """Configure world dimensions and auto-calculate movement parameters."""
-        self.world_width = width
-        self.world_height = height
-        
-        # Recalculate movement parameters based on new dimensions
-        self.movement_step = min(self.world_width, self.world_height) // 20
-        self.player_size = self.movement_step
-        self.tree_collision_radius = self.movement_step + 5
-        
-        print(f"[GameWorld] World configured: {width}x{height}, movement_step: {self.movement_step}")
+"""
+Game World Model
+
+This module contains the GameWorld class that manages the game state,
+players, NPCs, and world events.
+"""
+
+import time
+import threading
+from typing import Dict, List, Any, Optional
+from dataclasses import asdict
+
+from .player import Player
+
+
+class GameWorld:
+    """
+    Central game world state manager.
+    
+    Manages players, NPCs, chat messages, and world events.
+    Thread-safe operations using RLock.
+    """
+    
+    def __init__(self):
+        self.players: Dict[str, Player] = {}
+        self.npcs: Dict[str, Dict] = self._initialize_npcs()        # Tree positions for collision detection (matching UI)
+        self.trees = [
+            {'x':150,'y':100}, {'x':300,'y':200}, {'x':350,'y':150},
+            {'x':200,'y':300}, {'x':100,'y':250}, {'x':400,'y':320}
+        ]
+        self.chat_messages: List[Dict] = []
+        self.world_events: List[Dict] = []
+        self.addon_npcs: Dict[str, Any] = {}  # NPCAddon instances
+        self._lock = threading.RLock()  # Thread-safe operations        # World configuration
+        self.max_players = 20
+        self.world_width = 800
+        self.world_height = 600
+        self.chat_history_limit = 50
+        
+        # Movement configuration (scale with world size)
+        self.movement_step = min(self.world_width, self.world_height) // 20  # 25px for 500x400 world
+        self.player_size = self.movement_step  # Player collision radius
+        self.tree_collision_radius = self.movement_step + 5  # Tree collision radius
+        
+        # Add initial system message
+        self.add_chat_message("System", "🎮 Game server started!")
+    
+    def _initialize_npcs(self) -> Dict[str, Dict]:
+        """Initialize the default NPCs in the world."""
+        return {
+ """            'donald': {
+                'id': 'donald',
+                'name': 'Donald the Trader',
+                'x': 250, 'y': 100,
+                'char': '💼',
+                'type': 'trader',
+                'personality': 'donald'
+            },
+            'read2burn_mailbox': {
+                'id': 'read2burn_mailbox',
+                'name': 'Secure Mailbox',
+                'x': 200, 'y': 150,
+                'char': '📮',
+                'type': 'addon'
+            }, 
+            'merchant': {
+                'id': 'merchant',
+                'name': 'Tom the Trader',
+                'x': 300, 'y': 200,
+                'char': '🏪',
+                'type': 'basic'            },
+            'example_merchant': {
+                'id': 'example_merchant',
+                'name': 'Example Merchant',
+                'x': 350, 'y': 250,
+                'char': '🏪',
+                'type': 'addon'
+            }, """
+            'scholar': {
+                'id': 'scholar',
+                'name': 'Professor Wise',
+                'x': 100, 'y': 100,
+                'char': '📚',
+                'type': 'learning',
+                'personality': 'wise_teacher'
+            },
+"""             'jester': {
+                'id': 'jester',
+                'name': 'Funny Pete',
+                'x': 400, 'y': 100,
+                'char': '🃏',
+                'type': 'entertainment',
+                'personality': 'comedian'
+            }, """
+            'warrior': {
+                'id': 'warrior',
+                'name': 'Captain Steel',
+                'x': 350, 'y': 350,
+                'char': '⚔️',
+                'type': 'combat',
+                'personality': 'tough_trainer'
+            },
+"""             'healer': {
+                'id': 'healer',
+                'name': 'Sister Grace',
+                'x': 50, 'y': 250,
+                'char': '💚',
+                'type': 'healing',
+                'personality': 'gentle_healer'
+            }, """
+            'wanderer': {
+                'id': 'wanderer',
+                'name': 'Roaming Rick',
+                'x': 200, 'y': 200,
+                'char': '🚶',
+                'type': 'moving',
+                'personality': 'traveler',
+                'movement': {
+                    'speed': 2,
+                    'direction_x': 1,
+                    'direction_y': 1,
+                    'last_move': time.time()
+                }
+            },
+            'sage': {
+                'id': 'sage',
+                'name': 'Ancient Sage',
+                'x': 450, 'y': 250,
+                'char': '🧙',
+                'type': 'magic',
+                'personality': 'mystical_sage'
+            }
+        }
+
+    # Player Management
+    def add_player(self, player: Player) -> bool:
+        """Add a player to the world."""
+        print(f"[GameWorld.add_player] Adding {player.name}")
+        with self._lock:
+            if len(self.players) >= self.max_players:
+                return False
+            self.players[player.id] = player
+            self.add_chat_message("System", f"🎮 {player.name} ({player.type}) joined the game!")
+            print(f"[GameWorld] Player {player.name} added. Total players: {len(self.players)}")
+            return True
+    
+    def remove_player(self, player_id: str) -> bool:
+        """Remove a player from the world."""
+        with self._lock:
+            if player_id in self.players:
+                player = self.players[player_id]
+                self.add_chat_message("System", f"👋 {player.name} left the game!")
+                del self.players[player_id]
+                return True
+            return False
+
+    def get_player(self, player_id: str) -> Optional[Player]:
+        """Get a player by ID."""
+        with self._lock:
+            return self.players.get(player_id)
+
+    def get_all_players(self) -> Dict[str, Player]:
+        """Get all players (thread-safe copy)."""
+        with self._lock:
+            return self.players.copy()
+
+    # Movement and Positioning
+    def move_player(self, player_id: str, direction: str) -> bool:
+        """Move a player in the specified direction."""
+        with self._lock:
+            if player_id not in self.players:
+                return False
+            player = self.players[player_id]
+            old_x, old_y = player.x, player.y            # Determine candidate new position without moving
+            new_x, new_y = player.x, player.y
+            if direction == "up":
+                new_y = max(0, player.y - self.movement_step)
+            elif direction == "down":
+                new_y = min(self.world_height, player.y + self.movement_step)
+            elif direction == "left":
+                new_x = max(0, player.x - self.movement_step)
+            elif direction == "right":
+                new_x = min(self.world_width, player.x + self.movement_step)
+            
+            # Check tree collision
+            for tree in self.trees:
+                if abs(new_x - tree['x']) < self.tree_collision_radius and abs(new_y - tree['y']) < self.tree_collision_radius:
+                    # Collision: do not move
+                    return False
+            # Perform movement
+            player.move_to(new_x, new_y)
+            # Award experience and handle level-up
+            if old_x != player.x or old_y != player.y:
+                player.experience += 1
+                if player.can_level_up():
+                    player.level_up()
+                    self.add_chat_message("System", f"🎉 {player.name} reached level {player.level}!")
+                # Check for NPC proximity events
+                self.check_npc_proximity(player_id)
+                return True
+            return False
+
+    def check_npc_proximity(self, player_id: str):
+        """Check if player is near any NPCs and trigger interactions."""
+        player = self.players.get(player_id)
+        if not player:
+            return
+
+        interaction_range = 50
+        nearby_npcs = []
+        
+        for npc_id, npc_data in self.npcs.items():
+            npc_x, npc_y = npc_data['x'], npc_data['y']
+            distance = ((player.x - npc_x) ** 2 + (player.y - npc_y) ** 2) ** 0.5
+            
+            if distance <= interaction_range:
+                nearby_npcs.append(npc_data['name'])
+        
+        if nearby_npcs:
+            npc_list = ", ".join(nearby_npcs)
+            self.add_world_event(f"🔍 {player.name} is near: {npc_list}")
+
+    # Chat and Communication
+    def add_chat_message(self, sender: str, message: str, message_type: str = "public", 
+                        target: str = None, sender_id: str = None):
+        """Add a chat message to the world."""
+        with self._lock:
+            chat_msg = {
+                'sender': sender,
+                'message': message,
+                'timestamp': time.strftime("%H:%M:%S"),
+                'id': len(self.chat_messages),
+                'type': message_type,
+                'target': target,
+                'sender_id': sender_id
+            }
+            self.chat_messages.append(chat_msg)
+            if len(self.chat_messages) > self.chat_history_limit:
+                self.chat_messages = self.chat_messages[-self.chat_history_limit:]
+
+    def get_chat_history(self, limit: int = None) -> List[Dict]:
+        """Get chat message history."""
+        with self._lock:
+            if limit:
+                return self.chat_messages[-limit:]
+            return self.chat_messages.copy()
+
+    def add_world_event(self, event: str):
+        """Add a world event."""
+        with self._lock:
+            event_data = {
+                'event': event,
+                'timestamp': time.strftime("%H:%M:%S"),
+                'id': len(self.world_events)
+            }
+            self.world_events.append(event_data)
+            if len(self.world_events) > 20:  # Keep last 20 events
+                self.world_events = self.world_events[-20:]
+
+    def get_world_events(self) -> List[Dict]:
+        """Get world events history."""
+        with self._lock:
+            return self.world_events.copy()
+
+    # NPC Management
+    def add_npc(self, npc_id: str, npc_data: Dict):
+        """Add an NPC to the world."""
+        with self._lock:
+            self.npcs[npc_id] = npc_data
+
+    def get_npc(self, npc_id: str) -> Optional[Dict]:
+        """Get NPC data by ID."""
+        with self._lock:
+            return self.npcs.get(npc_id)
+
+    def get_all_npcs(self) -> Dict[str, Dict]:
+        """Get all NPCs."""
+        with self._lock:
+            return self.npcs.copy()
+
+    # Utility Methods
+    def get_world_state(self) -> Dict:
+        """Get the complete world state for debugging/monitoring."""
+        with self._lock:
+            return {
+                'players': {pid: asdict(player) for pid, player in self.players.items()},
+                'npcs': self.npcs.copy(),
+                'recent_chat': self.chat_messages[-10:],
+                'recent_events': self.world_events[-5:],
+                'stats': {
+                    'total_players': len(self.players),
+                    'total_npcs': len(self.npcs),
+                    'total_messages': len(self.chat_messages),
+                    'total_events': len(self.world_events)
+                }
+            }
+
+    def cleanup_inactive_players(self, timeout_seconds: int = 300):
+        """Remove players that have been inactive for too long."""
+        with self._lock:
+            inactive_players = [
+                player_id for player_id, player in self.players.items()
+                if not player.is_active(timeout_seconds)
+            ]
+            
+            for player_id in inactive_players:
+                self.remove_player(player_id)
+            
+            return len(inactive_players)
+    
+    def configure_world_dimensions(self, width: int, height: int):
+        """Configure world dimensions and auto-calculate movement parameters."""
+        self.world_width = width
+        self.world_height = height
+        
+        # Recalculate movement parameters based on new dimensions
+        self.movement_step = min(self.world_width, self.world_height) // 20
+        self.player_size = self.movement_step
+        self.tree_collision_radius = self.movement_step + 5
+        
+        print(f"[GameWorld] World configured: {width}x{height}, movement_step: {self.movement_step}")

src/interfaces/npc_addon.py

@@ -85,3 +85,18 @@ def clear_addon_registry():
     """Clear the addon registry (used for testing)"""
     global _addon_registry
     _addon_registry = {}
+    
+def list_active_addons() -> list:
+    """Return all currently registered addon IDs."""
+    return list(_addon_registry.keys())
+
+def remove_addon(addon_id: str) -> bool:
+    """Unregister and shut down an addon by its ID."""
+    addon = _addon_registry.pop(addon_id, None)
+    if addon:
+        try:
+            addon.on_shutdown()
+        except Exception:
+            pass
+        return True
+    return False

src/legacy_addons/example_npc_addon.py

@@ -0,0 +1,266 @@
+"""
+Example NPC Addon - Template for creating new NPCs with custom functionality
+"""
+
+import gradio as gr
+from typing import Dict, Any
+from src.interfaces.npc_addon import NPCAddon
+
+
+class ExampleNPCAddon(NPCAddon):
+    """Example NPC addon demonstrating the complete NPC creation process."""
+    
+    def __init__(self):
+        super().__init__()
+        # Initialize any state or data your NPC needs
+        self.npc_inventory = {
+            "health_potion": {"name": "Health Potion", "price": 25, "stock": 10},
+            "magic_scroll": {"name": "Magic Scroll", "price": 50, "stock": 5},
+            "steel_sword": {"name": "Steel Sword", "price": 100, "stock": 3}
+        }
+        self.greeting_messages = [
+            "Welcome to my shop, adventurer!",
+            "Looking for some fine wares?",
+            "I have the best deals in town!",
+            "What can I help you with today?"
+        ]
+    
+    @property
+    def addon_id(self) -> str:
+        """Unique identifier for this addon - must match NPC ID in world."""
+        return "example_merchant"
+    
+    @property
+    def addon_name(self) -> str:
+        """Display name shown in the interface."""
+        return "Example Merchant"
+    
+    def get_interface(self) -> gr.Component:
+        """Create the Gradio interface for this NPC."""
+        with gr.Column() as interface:
+            gr.Markdown("""
+            ## 🏪 Example Merchant
+            
+            *Welcome to my humble shop! I offer fine wares for brave adventurers.*
+            
+            ### Available Services:
+            - **Shop**: Browse and purchase items
+            - **Appraisal**: Get item value estimates  
+            - **Information**: Learn about the local area
+            
+            *Walk near me in the game world to unlock full functionality!*
+            """)
+            
+            with gr.Tabs():
+                # Shop Tab
+                with gr.Tab("🛒 Shop"):
+                    gr.Markdown("### Available Items")
+                    
+                    with gr.Row():
+                        item_select = gr.Dropdown(
+                            label="Select Item",
+                            choices=list(self.npc_inventory.keys()),
+                            value=None
+                        )
+                        quantity = gr.Number(
+                            label="Quantity",
+                            value=1,
+                            minimum=1,
+                            maximum=10
+                        )
+                    
+                    with gr.Row():
+                        buy_btn = gr.Button("💰 Purchase", variant="primary")
+                        refresh_btn = gr.Button("🔄 Refresh Stock", variant="secondary")
+                    
+                    purchase_result = gr.Textbox(
+                        label="Transaction Result",
+                        lines=3,
+                        interactive=False
+                    )
+                      # Shop display
+                    shop_display = gr.JSON(
+                        label="Current Inventory",
+                        value=self.npc_inventory
+                    )
+                    
+                    def handle_purchase(item_key, qty):
+                        if not item_key:
+                            return "❌ Please select an item first!"
+                        
+                        # Get current player (simplified for example)
+                        from ..core.game_engine import GameEngine
+                        game_engine = GameEngine()
+                        game_world = game_engine.get_world()
+                        current_players = list(game_world.players.keys())
+                        if not current_players:
+                            return "❌ You must be in the game to make purchases!"
+                        
+                        player_id = max(current_players, key=lambda pid: game_world.players[pid].last_active)
+                        return self.purchase_item(player_id, item_key, int(qty))
+                    
+                    def refresh_shop():
+                        return self.npc_inventory
+                    
+                    # Wire up the interface
+                    buy_btn.click(handle_purchase, [item_select, quantity], purchase_result)
+                    refresh_btn.click(refresh_shop, outputs=shop_display)
+                
+                # Information Tab
+                with gr.Tab("ℹ️ Information"):
+                    gr.Markdown("""
+                    ### 📍 Local Area Information
+                    
+                    - **Location**: Village Market Square
+                    - **Trading Hours**: Always open for brave adventurers
+                    - **Specialties**: Weapons, potions, and magical items
+                    - **Payment**: Gold coins accepted
+                    
+                    ### 🗺️ Nearby Locations
+                    - **Village Elder**: North of here, near the fountain
+                    - **Training Grounds**: East side of village
+                    - **Mystic Oracle**: In the tower to the south
+                    """)
+                    
+                    info_btn = gr.Button("📋 Get Quest Information")
+                    quest_info = gr.Textbox(
+                        label="Available Quests",
+                        lines=5,
+                        interactive=False
+                    )
+                    
+                    def get_quest_info():
+                        return """
+🗡️ **Available Quests:**
+
+1. **Goblin Problem** (Level 1-3)
+   - Clear goblins from the eastern caves
+   - Reward: 100 gold + basic equipment
+
+2. **Herb Collection** (Level 1-2)  
+   - Gather 10 healing herbs from the forest
+   - Reward: 50 gold + health potion
+
+3. **Lost Merchant** (Level 3-5)
+   - Find the missing merchant on the trade route
+   - Reward: 200 gold + rare item
+                        """
+                    
+                    info_btn.click(get_quest_info, outputs=quest_info)
+        
+        return interface
+    
+    def handle_command(self, player_id: str, command: str) -> str:
+        """Handle commands sent via private messages to this NPC."""
+        command_lower = command.lower().strip()
+          # Get player info safely
+        from ..core.game_engine import GameEngine
+        game_engine = GameEngine()
+        game_world = game_engine.get_world()
+        player = game_world.players.get(player_id)
+        if not player:
+            return "❌ Player not found!"
+        
+        player_name = player.name
+        
+        # Command parsing
+        if any(word in command_lower for word in ['hello', 'hi', 'greeting', 'hey']):
+            import random
+            return f"🏪 {random.choice(self.greeting_messages)} {player_name}!"
+        
+        elif any(word in command_lower for word in ['shop', 'buy', 'purchase', 'item']):
+            return self._get_shop_summary()
+        
+        elif any(word in command_lower for word in ['quest', 'mission', 'task']):
+            return "📜 I have information about local quests! Visit my Information tab for details."
+        
+        elif any(word in command_lower for word in ['help', 'commands']):
+            return """
+🏪 **Available Commands:**
+- **hello/hi**: Friendly greeting
+- **shop/buy**: View available items
+- **quest**: Learn about available quests  
+- **help**: Show this help message
+
+*Visit the NPC Add-ons tab for my full interface!*
+            """
+        
+        else:
+            return f"🤔 Interesting words, {player_name}! Try 'help' to see what I can do, or visit my shop interface in the NPC Add-ons tab!"
+    
+    def purchase_item(self, player_id: str, item_key: str, quantity: int) -> str:
+        """Handle item purchase logic."""
+        if item_key not in self.npc_inventory:
+            return "❌ Item not found in inventory!"
+        
+        item = self.npc_inventory[item_key]
+        total_cost = item["price"] * quantity
+        
+        if item["stock"] < quantity:
+            return f"❌ Not enough stock! Only {item['stock']} available."
+        
+        # Here you would check player's gold and deduct it
+        # For this example, we'll simulate the transaction
+        
+        # Update inventory
+        self.npc_inventory[item_key]["stock"] -= quantity
+        
+        return f"""
+✅ **Purchase Successful!**
+
+**Item**: {item['name']} x{quantity}
+**Cost**: {total_cost} gold
+**Remaining Stock**: {self.npc_inventory[item_key]['stock']}
+
+*Thank you for your business, adventurer!*
+        """
+    
+    def _get_shop_summary(self) -> str:
+        """Get a summary of available shop items."""
+        summary = "🏪 **Shop Inventory:**\n\n"
+        for key, item in self.npc_inventory.items():
+            if item["stock"] > 0:
+                summary += f"• **{item['name']}** - {item['price']} gold (Stock: {item['stock']})\n"
+        
+        summary += "\n*Visit my shop interface in the NPC Add-ons tab to purchase items!*"
+        return summary
+
+
+# Global instance for auto-registration
+example_merchant_addon = ExampleNPCAddon()
+
+
+def auto_register(game_engine):
+    """Auto-register the Example NPC addon with the game engine."""
+    try:
+        # Create addon instance
+        addon_instance = ExampleNPCAddon()
+        
+        # Get NPC config
+        npc_config = {
+            'id': 'example_merchant',
+            'name': '🏪 Example Merchant',
+            'x': 300, 'y': 250,
+            'char': '🏪',
+            'type': 'trader',
+            'personality': 'friendly'
+        }
+        
+        # Register NPC in world
+        npc_service = game_engine.get_npc_service()
+        npc_service.register_npc(npc_config['id'], npc_config)
+        
+        # Register addon for command handling
+        if not hasattr(game_engine.get_world(), 'addon_npcs'):
+            game_engine.get_world().addon_npcs = {}
+        game_engine.get_world().addon_npcs[npc_config['id']] = addon_instance
+        
+        # Call startup
+        addon_instance.on_startup()
+        
+        print(f"[ExampleNPCAddon] Auto-registered successfully as self-contained addon")
+        return True
+        
+    except Exception as e:
+        print(f"[ExampleNPCAddon] Error during auto-registration: {e}")
+        return False

src/legacy_addons/web_search_oracle_addon.py

@@ -0,0 +1,450 @@
+"""
+DuckDuckGo Search Oracle Add-on - MCP-powered DuckDuckGo search information system.
+"""
+
+import time
+import json
+import random
+import string
+import asyncio
+from typing import Dict, List, Optional
+import gradio as gr
+from abc import ABC, abstractmethod
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+from contextlib import AsyncExitStack
+
+from ..interfaces.npc_addon import NPCAddon
+
+
+class IDuckDuckGoSearchService(ABC):
+    """Interface for DuckDuckGo Search service operations."""
+    
+    @abstractmethod
+    def search_web(self, query: str) -> str:
+        """Search the web using DuckDuckGo."""
+        pass
+    
+    @abstractmethod
+    def connect_to_mcp(self) -> str:
+        """Connect to DuckDuckGo MCP server."""
+        pass
+
+
+class DuckDuckGoSearchOracleService(IDuckDuckGoSearchService, NPCAddon):
+    """Service for managing DuckDuckGo Search Oracle MCP integration."""
+    
+    def __init__(self):
+        super().__init__()
+        self.connected = False
+        self.last_connection_attempt = 0
+        self.connection_cooldown = 30  # 30 seconds between connection attempts
+        self.server_url = "https://agents-mcp-hackathon-duckduckgo-mcp-server.hf.space/gradio_api/mcp/sse"
+        self.session = None
+        self.tools = []
+        self.exit_stack = None
+        # Set up event loop for async operations
+        try:
+            self.loop = asyncio.get_event_loop()
+        except RuntimeError:
+            self.loop = asyncio.new_event_loop()    
+    @property
+    def addon_id(self) -> str:
+        """Unique identifier for this add-on"""
+        return "duckduckgo_search_oracle"
+    
+    @property
+    def addon_name(self) -> str:
+        """Display name for this add-on"""
+        return "DuckDuckGo Search Oracle (MCP)"
+    
+    @property
+    def npc_config(self) -> Dict:
+        """NPC configuration for auto-placement in world"""
+        return {
+            'id': 'duckduckgo_search_oracle',
+            'name': 'DuckDuckGo Search Oracle (MCP)',
+            'x': 450, 'y': 300,
+            'char': '🦆',
+            'type': 'mcp',
+            'description': 'DuckDuckGo-powered web search information service'
+        }
+    
+    @property
+    def ui_tab_name(self) -> str:
+        """UI tab name for this addon"""
+        return "DuckDuckGo Search Oracle"
+    
+    def get_interface(self) -> gr.Component:
+        """Return Gradio interface for this add-on"""
+        with gr.Column() as interface:            
+            gr.Markdown("""
+            ## 🦆 DuckDuckGo Search Oracle (MCP)
+            
+            *I commune with the DuckDuckGo search spirits through the mystical MCP protocol to bring you knowledge from across the web!*
+            
+            **Ask me to search for anything:**
+            - Current news and information
+            - Technical documentation
+            - Research topics
+            - General knowledge queries
+            - Powered by DuckDuckGo via Model Context Protocol (MCP)
+            
+            *Privacy-focused search powered by DuckDuckGo*
+            """)
+            
+            # Connection status
+            connection_status = gr.HTML(
+                value=f"<div style='color: {'green' if self.connected else 'red'};'>{'🟢 Connected to DuckDuckGo spirits' if self.connected else '🔴 Disconnected from DuckDuckGo realm'}</div>"
+            )
+            
+            with gr.Row():
+                query_input = gr.Textbox(
+                    label="Search Query",
+                    placeholder="e.g., latest news about AI, Python programming tutorials",
+                    scale=3                )
+                search_btn = gr.Button("🦆 Consult DuckDuckGo Spirits", variant="primary", scale=1)
+            
+            with gr.Row():
+                max_results = gr.Slider(
+                    minimum=1,
+                    maximum=10,
+                    value=5,
+                    step=1,
+                    label="Max Results",
+                    scale=2
+                )
+                engine_dropdown = gr.Dropdown(
+                    choices=["DuckDuckGo"],
+                    value="DuckDuckGo",
+                    label="Search Engine",
+                    scale=1
+                )
+            
+            search_output = gr.Textbox(
+                label="🔍 Search Wisdom",
+                lines=12,
+                interactive=False,
+                placeholder="Enter a search query and I will consult the search spirits..."
+            )
+            
+            # Example queries
+            with gr.Row():
+                gr.Examples(
+                    examples=[
+                        ["latest AI developments"],
+                        ["Python programming best practices"],
+                        ["climate change news 2024"],
+                        ["machine learning tutorials"],
+                        ["cryptocurrency market trends"],
+                        ["space exploration news"],
+                        ["renewable energy technologies"]
+                    ],
+                    inputs=[query_input],
+                    label="🌐 Try These Searches"
+                )
+            
+            # Connection controls
+            with gr.Row():
+                connect_btn = gr.Button("🔗 Connect to MCP", variant="secondary")
+                status_btn = gr.Button("📊 Check Status", variant="secondary")
+                tools_btn = gr.Button("🛠️ List Tools", variant="secondary")
+            
+            def handle_search_request(query: str, engine: str, max_results: int):
+                if not query.strip():
+                    return "❓ Please enter a search query to find information."
+                return self.search_web(query, engine, max_results)
+            
+            def handle_connect():
+                result = self.connect_to_mcp()
+                # Update connection status
+                new_status = f"<div style='color: {'green' if self.connected else 'red'};'>{'🟢 Connected to search spirits' if self.connected else '🔴 Disconnected from search realm'}</div>"
+                return result, new_status
+            
+            def handle_status():
+                status = "🟢 Connected" if self.connected else "🔴 Disconnected"
+                return f"🔍 **Web Search Oracle Status**\n\nConnection: {status}\nLast update: {time.strftime('%H:%M')}\nAvailable engines: {', '.join(self.search_engines)}"
+            
+            def handle_list_tools():
+                if not self.connected:
+                    return "❌ Not connected to MCP server. Please connect first."
+                if not self.tools:
+                    return "❌ No tools available."
+                
+                tool_info = "🛠️ **Available Search Tools:**\n\n"
+                for tool in self.tools:
+                    tool_info += f"• **{tool.name}**: {tool.description}\n"
+                return tool_info
+            
+            # Wire up events
+            search_btn.click(
+                handle_search_request,
+                inputs=[query_input, engine_dropdown, max_results],
+                outputs=[search_output]
+            )
+            
+            query_input.submit(
+                handle_search_request,
+                inputs=[query_input, engine_dropdown, max_results], 
+                outputs=[search_output]
+            )
+            
+            connect_btn.click(
+                handle_connect,
+                outputs=[search_output, connection_status]
+            )
+            
+            status_btn.click(
+                handle_status,
+                outputs=[search_output]
+            )
+            
+            tools_btn.click(
+                handle_list_tools,
+                outputs=[search_output]
+            )
+        
+        return interface
+    
+    def connect_to_mcp(self) -> str:
+        """Connect to MCP web search server."""
+        current_time = time.time()
+        if current_time - self.last_connection_attempt < self.connection_cooldown:
+            return "⏳ Please wait before retrying connection..."
+        
+        self.last_connection_attempt = current_time
+        
+        try:
+            return self.loop.run_until_complete(self._connect())
+        except Exception as e:
+            self.connected = False
+            return f"❌ Connection failed: {str(e)}"
+    
+    async def _connect(self) -> str:
+        """Async connect to MCP server using SSE."""
+        try:
+            # Clean up previous connection
+            if self.exit_stack:
+                await self.exit_stack.aclose()
+
+            self.exit_stack = AsyncExitStack()
+
+            # Connect to SSE MCP server
+            sse_transport = await self.exit_stack.enter_async_context(
+                sse_client(self.server_url)
+            )
+            read_stream, write_callable = sse_transport
+
+            self.session = await self.exit_stack.enter_async_context(
+                ClientSession(read_stream, write_callable)
+            )
+            await self.session.initialize()
+
+            # Get available tools
+            response = await self.session.list_tools()
+            self.tools = response.tools
+
+            self.connected = True
+            tool_names = [tool.name for tool in self.tools]
+            return f"✅ Connected to web search MCP server!\nAvailable tools: {', '.join(tool_names)}"
+
+        except Exception as e:
+            self.connected = False
+            return f"❌ Connection failed: {str(e)}"
+    
+    def search_web(self, query: str, engine: str = "brave", max_results: int = 5) -> str:
+        """Search the web using actual MCP server"""
+        if not self.connected:
+            # Try to auto-connect
+            connect_result = self.connect_to_mcp()
+            if not self.connected:
+                return f"❌ Failed to connect to search server. {connect_result}"
+        
+        if not query.strip():
+            return "❌ Please enter a search query"
+        
+        try:
+            return self.loop.run_until_complete(self._search_web(query, engine, max_results))
+        except Exception as e:
+            return f"❌ Error performing search: {str(e)}"
+    
+    async def _search_web(self, query: str, engine: str, max_results: int) -> str:
+        """Async search web using MCP."""
+        try:
+            # Find the appropriate search tool based on engine
+            tool_name = f"web_search_mcp_{engine}_search"
+            search_tool = next((tool for tool in self.tools if tool.name == tool_name), None)
+            
+            if not search_tool:
+                # Try to find any search tool if specific engine not found
+                search_tool = next((tool for tool in self.tools if 'search' in tool.name.lower()), None)
+                if not search_tool:
+                    return "❌ No search tools found on server"
+
+            # Call the tool
+            params = {"query": query}
+            result = await self.session.call_tool(search_tool.name, params)
+
+            # Extract content properly
+            content_text = ""
+            if hasattr(result, 'content') and result.content:
+                if isinstance(result.content, list):
+                    for content_item in result.content:
+                        if hasattr(content_item, 'text'):
+                            content_text += content_item.text
+                        elif hasattr(content_item, 'content'):
+                            content_text += str(content_item.content)
+                        else:
+                            content_text += str(content_item)
+                elif hasattr(result.content, 'text'):
+                    content_text = result.content.text
+                else:
+                    content_text = str(result.content)
+
+            if not content_text:
+                return "❌ No content received from server"
+
+            try:
+                # Try to parse as JSON
+                parsed = json.loads(content_text)
+                if isinstance(parsed, dict):
+                    if 'error' in parsed:
+                        return f"❌ Error: {parsed['error']}"
+
+                    # Format search results nicely
+                    formatted = f"🔍 **Search Results for: '{query}'**\n"
+                    formatted += f"🌐 **Engine: {engine.title()}**\n\n"
+                    
+                    # Handle different response formats
+                    if 'data' in parsed and isinstance(parsed['data'], list):
+                        results = parsed['data'][:max_results]
+                        for i, result_item in enumerate(results, 1):
+                            if isinstance(result_item, list) and len(result_item) >= 3:
+                                title, link, body = result_item[0], result_item[1], result_item[2]
+                                formatted += f"**{i}. {title}**\n"
+                                formatted += f"🔗 {link}\n"
+                                formatted += f"📝 {body[:200]}{'...' if len(body) > 200 else ''}\n\n"
+                            elif isinstance(result_item, dict):
+                                title = result_item.get('title', 'No title')
+                                link = result_item.get('link', 'No link')
+                                body = result_item.get('body', 'No description')
+                                formatted += f"**{i}. {title}**\n"
+                                formatted += f"🔗 {link}\n"
+                                formatted += f"📝 {body[:200]}{'...' if len(body) > 200 else ''}\n\n"
+                    elif 'results' in parsed:
+                        results = parsed['results'][:max_results]
+                        for i, result_item in enumerate(results, 1):
+                            title = result_item.get('title', 'No title')
+                            link = result_item.get('url', result_item.get('link', 'No link'))
+                            body = result_item.get('snippet', result_item.get('body', 'No description'))
+                            formatted += f"**{i}. {title}**\n"
+                            formatted += f"🔗 {link}\n"
+                            formatted += f"📝 {body[:200]}{'...' if len(body) > 200 else ''}\n\n"
+                    else:
+                        # Fallback to raw JSON display
+                        formatted += f"✅ Raw search data:\n```json\n{json.dumps(parsed, indent=2)}\n```"
+                    
+                    formatted += f"\n⏰ Search completed: {time.strftime('%H:%M')}\n⚡ **Powered by MCP**"
+                    return formatted
+
+            except json.JSONDecodeError:
+                # If not JSON, try to format as text
+                formatted = f"🔍 **Search Results for: '{query}'**\n"
+                formatted += f"🌐 **Engine: {engine.title()}**\n\n"
+                formatted += f"✅ Search data:\n```\n{content_text[:1000]}{'...' if len(content_text) > 1000 else ''}\n```\n\n"
+                formatted += f"⏰ Search completed: {time.strftime('%H:%M')}\n⚡ **Powered by MCP**"
+                return formatted
+
+            return f"🔍 **Search Results for: '{query}'**\n\n✅ Raw result:\n{content_text[:1000]}{'...' if len(content_text) > 1000 else ''}\n\n⚡ **Powered by MCP**"
+
+        except Exception as e:
+            return f"❌ Failed to search: {str(e)}"
+    
+    def handle_command(self, player_id: str, command: str) -> str:
+        """Handle Web Search Oracle commands."""
+        parts = command.strip().split(' ', 2)
+        cmd = parts[0].lower()
+        
+        if cmd == "search" and len(parts) > 1:
+            query = parts[1]
+            engine = "brave"  # default
+            if len(parts) > 2 and parts[2] in self.search_engines:
+                engine = parts[2]
+            return self.search_web(query, engine)
+        elif cmd == "engines":
+            return f"🔍 **Available Search Engines:**\n\n{', '.join(self.search_engines)}\n\n**Usage:** `search <query> [engine]`"
+        elif cmd == "connect":
+            return self.connect_to_mcp()
+        elif cmd == "status":
+            status = "🟢 Connected" if self.connected else "🔴 Disconnected"
+            return f"🔍 **Web Search Oracle Status**\n\nConnection: {status}\nLast update: {time.strftime('%H:%M')}\nAvailable engines: {', '.join(self.search_engines)}"
+        elif cmd == "tools":
+            if not self.connected:
+                return "❌ Not connected to MCP server. Use `connect` first."
+            if not self.tools:
+                return "❌ No tools available."
+            
+            tool_info = "🛠️ **Available Search Tools:**\n\n"
+            for tool in self.tools:
+                tool_info += f"• **{tool.name}**: {tool.description}\n"
+            return tool_info
+        elif cmd == "help":
+            return """🔍 **Web Search Oracle Commands:**
+
+**search** `<query>` `[engine]` - Search the web (e.g., 'search AI news brave')
+**engines** - List available search engines
+**connect** - Connect to MCP search server
+**status** - Check connection status
+**tools** - List available MCP tools
+**help** - Show this help
+
+🌐 **Available Engines:**
+{engines}
+
+🔍 **Example Commands:**
+• search latest AI developments
+• search Python tutorials duckduckgo
+• search climate change news searxng
+
+⚡ **Powered by MCP (Model Context Protocol)**""".format(engines=', '.join(self.search_engines))
+        else:
+            return "❓ Invalid command. Try: `search <query>`, `engines`, `connect`, `status`, `tools`, or `help`"
+
+
+# Global Web Search Oracle service instance
+web_search_oracle_service = DuckDuckGoSearchOracleService()
+
+
+def auto_register(game_engine):
+    """Auto-register the Web Search Oracle addon with the game engine.
+    
+    This function makes the addon self-contained by handling its own registration.
+    """
+    try:
+        # Create the web search oracle NPC definition
+        web_search_oracle_npc = {
+            'id': 'web_search_oracle_auto',
+            'name': '🔍 Web Search Oracle (Auto)',
+            'x': 550, 'y': 100,
+            'char': '🔍',
+            'type': 'mcp',
+            'personality': 'web_search_oracle',
+            'description': 'Self-contained MCP-powered web search information service'
+        }
+        
+        # Register the NPC with the NPC service
+        npc_service = game_engine.get_npc_service()
+        npc_service.register_npc('web_search_oracle_auto', web_search_oracle_npc)
+        
+        # Register the addon for handling private message commands
+        world = game_engine.get_world()
+        if not hasattr(world, 'addon_npcs'):
+            world.addon_npcs = {}
+        world.addon_npcs['web_search_oracle_auto'] = web_search_oracle_service
+        
+        print("[WebSearchOracleAddon] Auto-registered successfully as self-contained addon")
+        return True
+        
+    except Exception as e:
+        print(f"[WebSearchOracleAddon] Error during auto-registration: {e}")
+        return False

src/ui/__init__.py

@@ -5,7 +5,8 @@ This module contains all user interface components for the MMORPG application.
 """
 
 from .interface_manager import InterfaceManager
+from .improved_interface_manager import ImprovedInterfaceManager
 from .huggingface_ui import HuggingFaceUI
 from .documentation_tabs import DocumentationTabs
 
-__all__ = ['InterfaceManager', 'HuggingFaceUI', 'DocumentationTabs']
+__all__ = ['InterfaceManager', 'ImprovedInterfaceManager', 'HuggingFaceUI', 'DocumentationTabs']

src/ui/huggingface_ui.py

@@ -32,12 +32,11 @@ class HuggingFaceUI:
             radius_size="md",
             spacing_size="md"
         )
-        
-        # Custom CSS for HuggingFace-like styling
+          # Custom CSS for HuggingFace-like styling with enhanced design
         self.custom_css = """
-        /* HuggingFace-inspired styling */
+        /* HuggingFace-inspired styling with modern enhancements */
         .main-container {
-            max-width: 1200px;
+            max-width: 1400px;
             margin: 0 auto;
             padding: 20px;
         }
@@ -49,12 +48,14 @@ class HuggingFaceUI:
             border-radius: 12px;
             margin-bottom: 30px;
             text-align: center;
+            box-shadow: 0 4px 20px rgba(0,0,0,0.1);
         }
         
         .hero-title {
             font-size: 2.5em;
             font-weight: bold;
             margin-bottom: 10px;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
         }
         
         .hero-subtitle {
@@ -72,67 +73,87 @@ class HuggingFaceUI:
             background: white;
             border-radius: 12px;
             padding: 20px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            box-shadow: 0 4px 15px rgba(0,0,0,0.1);
             margin-bottom: 20px;
+            border: 1px solid #e9ecef;
         }
         
         .stats-card {
-            background: #f8f9fa;
-            border: 1px solid #e9ecef;
-            border-radius: 8px;
-            padding: 15px;
-            margin: 10px 0;
+            background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
+            border: 1px solid #dee2e6;
+            border-radius: 12px;
+            padding: 20px;
+            margin: 15px 0;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.08);
         }
         
         .movement-grid {
             display: grid;
-            grid-template-columns: 1fr 1fr 1fr;
-            gap: 10px;
-            max-width: 200px;
-            margin: 0 auto;
+            grid-template-columns: repeat(3, 60px);
+            gap: 12px;
+            max-width: 220px;
+            margin: 15px auto;
+            justify-content: center;
         }
         
         .movement-btn {
-            padding: 12px;
-            font-size: 20px;
-            border-radius: 8px;
+            width: 60px;
+            height: 60px;
+            border-radius: 12px;
             border: 2px solid #007bff;
-            background: #f8f9fa;
+            background: linear-gradient(135deg, #ffffff 0%, #f8f9fa 100%);
+            font-size: 18px;
+            font-weight: bold;
             cursor: pointer;
-            transition: all 0.2s;
+            transition: all 0.3s ease;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            box-shadow: 0 2px 8px rgba(0,123,255,0.2);
         }
         
         .movement-btn:hover {
-            background: #007bff;
+            background: linear-gradient(135deg, #007bff 0%, #0056b3 100%);
             color: white;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(0,123,255,0.4);
+        }
+        
+        .movement-btn:active {
+            transform: translateY(0px);
+            box-shadow: 0 2px 6px rgba(0,123,255,0.3);
         }
         
         .keyboard-status {
-            background: #e8f5e8;
+            background: linear-gradient(135deg, #e8f5e8 0%, #d4edda 100%);
             border: 2px solid #4caf50;
             border-radius: 8px;
             padding: 12px;
             margin: 10px 0;
             text-align: center;
             font-weight: bold;
+            box-shadow: 0 2px 8px rgba(76,175,80,0.2);
         }
         
         .tab-content {
-            padding: 20px;
+            padding: 25px;
             min-height: 600px;
+            background: #fafafa;
+            border-radius: 8px;
         }
         
         .doc-section {
             margin-bottom: 30px;
-            padding: 20px;
+            padding: 25px;
             border-left: 4px solid #007bff;
-            background: #f8f9fa;
-            border-radius: 0 8px 8px 0;
+            background: linear-gradient(135deg, #f8f9fa 0%, #ffffff 100%);
+            border-radius: 0 12px 12px 0;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
         }
         
         .feature-grid {
             display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
             gap: 20px;
             margin: 20px 0;
         }
@@ -140,55 +161,73 @@ class HuggingFaceUI:
         .feature-card {
             background: white;
             border: 1px solid #e9ecef;
-            border-radius: 8px;
-            padding: 20px;
-            box-shadow: 0 2px 5px rgba(0,0,0,0.05);
+            border-radius: 12px;
+            padding: 25px;
+            box-shadow: 0 4px 15px rgba(0,0,0,0.08);
+            transition: all 0.3s ease;
+        }
+        
+        .feature-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 8px 25px rgba(0,0,0,0.15);
         }
         
         .feature-icon {
-            font-size: 2em;
-            margin-bottom: 10px;
+            font-size: 2.5em;
+            margin-bottom: 15px;
             display: block;
+            text-align: center;
         }
         
         .chat-tab {
-            background: #f5f5f5;
-            border: 1px solid #ccc;
+            background: linear-gradient(135deg, #f5f5f5 0%, #e9ecef 100%);
+            border: 2px solid #dee2e6;
             border-radius: 8px;
-            padding: 8px 12px;
-            margin: 2px;
+            padding: 10px 16px;
+            margin: 3px;
             cursor: pointer;
             display: inline-flex;
             align-items: center;
-            gap: 5px;
-            transition: all 0.2s;
+            gap: 8px;
+            transition: all 0.3s ease;
+            font-weight: 500;
         }
         
         .chat-tab.active {
-            background: #e3f2fd;
+            background: linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%);
             border-color: #2196f3;
-            border-width: 2px;
+            color: #1976d2;
+            box-shadow: 0 2px 8px rgba(33,150,243,0.3);
         }
         
         .chat-tab:hover {
-            background: #e9ecef;
+            background: linear-gradient(135deg, #e9ecef 0%, #dee2e6 100%);
+            transform: translateY(-1px);
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
         }
         
         .npc-addon-panel {
-            border: 1px solid #e9ecef;
-            border-radius: 8px;
-            padding: 15px;
-            margin: 10px 0;
-            background: #fafafa;
+            border: 2px solid #e9ecef;
+            border-radius: 12px;
+            padding: 20px;
+            margin: 15px 0;
+            background: linear-gradient(135deg, #fafafa 0%, #ffffff 100%);
+            box-shadow: 0 2px 10px rgba(0,0,0,0.05);
         }
         
         .plugin-card {
             background: white;
-            border: 1px solid #e9ecef;
-            border-radius: 8px;
-            padding: 15px;
-            margin: 10px 0;
-            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+            border: 2px solid #e9ecef;
+            border-radius: 12px;
+            padding: 20px;
+            margin: 15px 0;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.08);
+            transition: all 0.3s ease;
+        }
+        
+        .plugin-card:hover {
+            border-color: #007bff;
+            box-shadow: 0 4px 15px rgba(0,123,255,0.15);
         }
         
         .status-indicator {
@@ -197,16 +236,54 @@ class HuggingFaceUI:
             height: 12px;
             border-radius: 50%;
             margin-right: 8px;
+            box-shadow: 0 0 0 2px white, 0 0 0 3px currentColor;
+        }
+        
+        .status-online { 
+            background-color: #4caf50;
+            animation: pulse-green 2s infinite;
+        }
+        .status-offline { 
+            background-color: #f44336;
+        }
+        .status-idle { 
+            background-color: #ff9800;
         }
         
-        .status-online { background-color: #4caf50; }
-        .status-offline { background-color: #f44336; }
-        .status-idle { background-color: #ff9800; }
+        @keyframes pulse-green {
+            0% { box-shadow: 0 0 0 2px white, 0 0 0 3px #4caf50; }
+            50% { box-shadow: 0 0 0 2px white, 0 0 0 6px rgba(76,175,80,0.5); }
+            100% { box-shadow: 0 0 0 2px white, 0 0 0 3px #4caf50; }
+        }
+        
+        /* Enhanced buttons */
+        .gradio-button {
+            border-radius: 8px !important;
+            font-weight: 600 !important;
+            transition: all 0.3s ease !important;
+        }
+        
+        .gradio-button:hover {
+            transform: translateY(-1px) !important;
+            box-shadow: 0 4px 12px rgba(0,0,0,0.15) !important;
+        }
+        
+        /* Enhanced form controls */
+        .gradio-textbox, .gradio-dropdown, .gradio-slider {
+            border-radius: 8px !important;
+            border: 2px solid #e9ecef !important;
+            transition: all 0.3s ease !important;
+        }
+        
+        .gradio-textbox:focus, .gradio-dropdown:focus {
+            border-color: #007bff !important;
+            box-shadow: 0 0 0 3px rgba(0,123,255,0.1) !important;
+        }
         
         /* Responsive design */
         @media (max-width: 768px) {
             .main-container {
-                padding: 10px;
+                padding: 15px;
             }
             
             .hero-section {
@@ -220,6 +297,37 @@ class HuggingFaceUI:
             .feature-grid {
                 grid-template-columns: 1fr;
             }
+            
+            .movement-grid {
+                grid-template-columns: repeat(3, 50px);
+                gap: 8px;
+            }
+            
+            .movement-btn {
+                width: 50px;
+                height: 50px;
+                font-size: 16px;
+            }
+        }
+        
+        /* Dark mode support */
+        @media (prefers-color-scheme: dark) {
+            .doc-section {
+                background: linear-gradient(135deg, #2d3748 0%, #4a5568 100%);
+                color: white;
+            }
+            
+            .feature-card {
+                background: #2d3748;
+                border-color: #4a5568;
+                color: white;
+            }
+            
+            .npc-addon-panel, .plugin-card {
+                background: #2d3748;
+                border-color: #4a5568;
+                color: white;
+            }
         }
         """
     
@@ -446,13 +554,47 @@ class HuggingFaceUI:
         )
     
     def _generate_world_html(self, width: int = 800, height: int = 600) -> str:
-        """Generate HTML for the game world visualization with bigger map."""
+        """Generate HTML for the game world visualization with enhanced tooltips."""
         # Enhanced game world with tree collision detection
-        # Dynamically generate NPCs from GameFacade
+        # Dynamically generate NPCs from GameFacade with enhanced tooltips from addons
         npc_html = ""
         for npc in self.game_facade.get_all_npcs().values():
-            npc_html += f"<div style=\"position: absolute; left: {npc['x']}px; top: {npc['y']}px; font-size: 25px;\" title=\"{npc['name']}\">{npc['char']}</div>"
-        # Base world template
+            # Get rich tooltip information from addon system
+            tooltip_info = self._get_npc_tooltip_info(npc)
+            
+            npc_html += f"""
+            <div style="position: absolute; left: {npc['x']}px; top: {npc['y']}px; text-align: center;" 
+                 title="{tooltip_info}"
+                 class="npc-hover-element">
+                <div style="font-size: 25px; line-height: 1;">{npc['char']}</div>
+                <div style="font-size: 7px; font-weight: bold; color: #333; background: rgba(255,255,255,0.8); 
+                           padding: 1px 3px; border-radius: 3px; margin-top: 2px; white-space: nowrap;">{npc['name']}</div>
+            </div>"""
+        
+        # Generate player tooltips with enhanced information
+        players_html = ""
+        try:
+            players = self.game_facade.get_all_players()
+            for player_id, player in players.items():
+                player_tooltip = self._get_player_tooltip_info(player)
+                players_html += f"""
+                <div style="position: absolute; left: {player.x}px; top: {player.y}px; 
+                           font-size: 20px; z-index: 10; border: 2px solid yellow; border-radius: 50%;
+                           text-shadow: 2px 2px 4px rgba(0,0,0,0.5);" 
+                     title="{player_tooltip}"
+                     class="player-hover-element">
+                    🧑‍🦰
+                </div>
+                
+                <div style="position: absolute; left: {player.x - 15}px; top: {player.y - 15}px;
+                           background: rgba(255,215,0,0.9); color: black; padding: 1px 4px;
+                           border-radius: 3px; font-size: 8px; font-weight: bold; z-index: 11;">
+                    {player.name} (Lv.{player.level})
+                </div>"""
+        except Exception as e:
+            print(f"[UI] Error generating player tooltips: {e}")
+        
+        # Base world template with enhanced tooltip styling
         world_html = f"""
         <div style="position: relative; width: {width}px; height: {height}px; 
                     border: 3px solid #333; border-radius: 12px; 
@@ -460,44 +602,137 @@ class HuggingFaceUI:
                     margin: 20px auto; overflow: hidden; box-shadow: 0 4px 15px rgba(0,0,0,0.2);">
             
             <!-- Trees for collision detection -->
-            <div style="position: absolute; left: 150px; top: 100px; font-size: 30px;">🌳</div>
-            <div style="position: absolute; left: 300px; top: 200px; font-size: 30px;">🌳</div>
-            <div style="position: absolute; left: 500px; top: 150px; font-size: 30px;">🌳</div>
-            <div style="position: absolute; left: 650px; top: 300px; font-size: 30px;">🌳</div>
-            <div style="position: absolute; left: 200px; top: 400px; font-size: 30px;">🌳</div>
-            <div style="position: absolute; left: 450px; top: 450px; font-size: 30px;">🌳</div>
-            <div style="position: absolute; left: 600px; top: 500px; font-size: 30px;">🌳</div>
+            <div style="position: absolute; left: 150px; top: 100px; font-size: 30px;" title="Ancient Oak - Blocks movement">🌳</div>
+            <div style="position: absolute; left: 300px; top: 200px; font-size: 30px;" title="Forest Pine - Collision object">🌳</div>
+            <div style="position: absolute; left: 500px; top: 150px; font-size: 30px;" title="Mystical Tree - Impassable">🌳</div>
+            <div style="position: absolute; left: 650px; top: 300px; font-size: 30px;" title="Old Growth Tree - Blocks path">🌳</div>
+            <div style="position: absolute; left: 200px; top: 400px; font-size: 30px;" title="Willow Tree - Natural barrier">🌳</div>
+            <div style="position: absolute; left: 450px; top: 450px; font-size: 30px;" title="Sacred Grove Tree - Protected">🌳</div>
+            <div style="position: absolute; left: 600px; top: 500px; font-size: 30px;" title="Elder Tree - Wise and immovable">🌳</div>
             
-            <!-- NPCs -->
+            <!-- NPCs with enhanced tooltips -->
             {npc_html}
             
-            <!-- Decorative elements -->
-            <div style="position: absolute; left: 50px; top: 50px; font-size: 20px;">🏔️</div>
-            <div style="position: absolute; right: 50px; top: 50px; font-size: 20px;">🏔️</div>
-            <div style="position: absolute; left: 50px; bottom: 50px; font-size: 20px;">🌊</div>
-            <div style="position: absolute; right: 50px; bottom: 50px; font-size: 20px;">🌊</div>
+            <!-- Decorative elements with tooltips -->
+            <div style="position: absolute; left: 50px; top: 50px; font-size: 20px;" title="Northern Mountains - Unexplored peaks">🏔️</div>
+            <div style="position: absolute; right: 50px; top: 50px; font-size: 20px;" title="Eastern Peaks - Dragon territory">🏔️</div>
+            <div style="position: absolute; left: 50px; bottom: 50px; font-size: 20px;" title="Western Waters - Crystal clear lakes">🌊</div>
+            <div style="position: absolute; right: 50px; bottom: 50px; font-size: 20px;" title="Southern Seas - Endless horizon">🌊</div>
             
             <!-- Players will be dynamically added here -->
-            <div id="players-container"></div>
-            
-            <!-- Legend 
-            <div style="position: absolute; top: 10px; left: 10px; background: rgba(255,255,255,0.9); 
-                        padding: 10px; border-radius: 8px; font-size: 12px; box-shadow: 0 2px 5px rgba(0,0,0,0.2);">
-                <strong>🗺️ Game World ({width}x{height})</strong><br>
-                🧑‍🦰 Players | 📮🏪🚶🧙🌤️ NPCs | 🌳 Trees (collision)
-            </div>
-            -->
-            
-            <!-- Coordinates display 
-            <div style="position: absolute; bottom: 10px; right: 10px; background: rgba(0,0,0,0.7); 
-                        color: white; padding: 8px; border-radius: 5px; font-size: 11px;">
-                <span id="coordinates">Move to see coordinates</span>
+            <div id="players-container">
+                {players_html}
             </div>
-            -->
-        </div>
+              <!-- Enhanced tooltip styling -->
+            <style>
+                .npc-hover-element, .player-hover-element {{
+                    cursor: pointer;
+                    transition: transform 0.2s ease;
+                }}
+                .npc-hover-element:hover, .player-hover-element:hover {{
+                    transform: scale(1.1);
+                    z-index: 100;
+                }}
+                
+                /* Enhanced tooltip styling */
+                [title] {{
+                    position: relative;
+                }}
+                
+                /* Custom tooltip appearance - wider and more readable */
+                div[title]:hover::after {{
+                    content: attr(title);
+                    position: absolute;
+                    bottom: 100%;
+                    left: 50%;
+                    transform: translateX(-50%);
+                    background: rgba(0, 0, 0, 0.9);
+                    color: white;
+                    padding: 12px 16px;
+                    border-radius: 8px;
+                    font-size: 14px;
+                    white-space: pre-line;
+                    min-width: 200px;
+                    max-width: 400px;
+                    z-index: 1000;
+                    box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+                    border: 1px solid #555;
+                    text-align: center;
+                    line-height: 1.4;
+                }}
+            </style>
+              <div style="position: absolute; top: 10px; left: 10px; background: rgba(255,255,255,0.9); 
+                        padding: 10px; border-radius: 8px; font-size: 12px; box-shadow: 0 2px 5px rgba(0,0,0,0.2);">
+                🌍 <strong>Fantasy Realm</strong> |
+                Players: {len(players) if 'players' in locals() else 0}/20 |
+                Hover over NPCs and players for information
+                <br>
+                🧑‍🦰 Players | 📮🏪🚶🧙🌤️ NPCs | 🌳 Trees 
+             </div>        </div>
         """
         return world_html
     
+    def _get_npc_tooltip_info(self, npc: dict) -> str:
+        """Generate simple tooltip information for an NPC from addon data."""
+        try:
+            # Get addon information if available
+            from ..interfaces.npc_addon import get_registered_addons
+            registered_addons = get_registered_addons()
+            
+            # Try to find matching addon
+            addon = None
+            npc_id = npc.get('id', '')
+            
+            # Search for addon by NPC ID or name matching
+            for addon_id, registered_addon in registered_addons.items():
+                if hasattr(registered_addon, 'npc_config') and registered_addon.npc_config:
+                    addon_npc_id = registered_addon.npc_config.get('id', '')
+                    if addon_npc_id == npc_id or addon_npc_id in npc_id:
+                        addon = registered_addon
+                        break
+            
+            # Use description from addon's npc_config if available
+            if addon and hasattr(addon, 'npc_config') and addon.npc_config:
+                description = addon.npc_config.get('description', '')
+                if description:
+                    return description
+            
+            # Fallback to basic NPC description
+            return npc.get('description', f"{npc['name']} - Interactive NPC")
+            
+        except Exception as e:
+            print(f"[UI] Error generating NPC tooltip for {npc.get('name', 'Unknown')}: {e}")
+            return f"{npc['name']} - Interactive NPC"
+    
+    def _get_player_tooltip_info(self, player) -> str:
+        """Generate rich tooltip information for a player."""
+        try:
+            tooltip = f"👤 {player.name}\n"
+            tooltip += f"⭐ Level: {player.level}\n"
+            tooltip += f"❤️ Health: {player.hp}/{player.max_hp}\n"
+            tooltip += f"💰 Gold: {getattr(player, 'gold', 0)}\n"
+            tooltip += f"🎯 XP: {player.experience}\n"
+            tooltip += f"📍 Position: ({player.x}, {player.y})\n"
+            
+            # Add status information
+            if hasattr(player, 'last_active'):
+                import time
+                time_diff = time.time() - player.last_active
+                if time_diff < 30:
+                    tooltip += "🟢 Status: Active"
+                elif time_diff < 300:
+                    tooltip += "🟡 Status: Away"
+                else:
+                    tooltip += "🔴 Status: Idle"
+            
+            tooltip += "\n\n💬 Walk near to start private chat"
+            
+            return tooltip
+            
+        except Exception as e:
+            print(f"[UI] Error generating player tooltip: {e}")
+            return f"{getattr(player, 'name', 'Player')}\n💬 Interactive player - Walk near to chat"
+    
     def create_interface(self) -> gr.Blocks:
         """Create the complete HuggingFace-style interface."""
         
@@ -1044,32 +1279,148 @@ class HuggingFaceUI:
                 )
             
             with gr.Tab("🧪 AI Agent Testing"):
-                gr.Markdown("## 🧪 Test AI Agent Integration")
-                gr.Markdown("*Use this to simulate AI agent connections for testing*")
-                
-                with gr.Row():
-                    ai_name = gr.Textbox(
-                        label="AI Agent Name",
-                        placeholder="Claude the Explorer",
-                        scale=3
-                    )
-                    register_ai_btn = gr.Button("Register AI Agent", variant="primary", scale=1)
-                
-                with gr.Row():
-                    ai_action = gr.Dropdown(
-                        choices=["move up", "move down", "move left", "move right", "chat"],
-                        label="AI Action",
-                        scale=2
-                    )
-                    ai_message = gr.Textbox(
-                        label="AI Message (for chat)",
-                        placeholder="Hello humans!",
-                        scale=3
-                    )
-                
-                execute_ai_btn = gr.Button("Execute AI Action", variant="secondary")
-                ai_result = gr.Textbox(label="AI Action Result", interactive=False, lines=5)
+                self._create_ai_testing_tab()
+
+    def _create_ai_testing_tab(self):
+        """Create enhanced AI testing tab."""
+        gr.Markdown("## 🧪 Test AI Agent Integration")
+        gr.Markdown("*Use this to simulate AI agent connections for testing*")
+        
+        with gr.Row():
+            ai_name = gr.Textbox(
+                label="AI Agent Name",
+                placeholder="Claude the Explorer",
+                scale=3
+            )
+            register_ai_btn = gr.Button("Register AI Agent", variant="primary", scale=1)
+        
+        with gr.Row():
+            ai_action = gr.Dropdown(
+                choices=["move up", "move down", "move left", "move right", "chat"],
+                label="AI Action",
+                scale=2
+            )
+            ai_message = gr.Textbox(
+                label="AI Message (for chat)",
+                placeholder="Hello humans!",
+                scale=3
+            )
+        
+        execute_ai_btn = gr.Button("Execute AI Action", variant="secondary")
+        ai_result = gr.Textbox(label="AI Action Result", interactive=False, lines=5)
+        
+        # Raw Data Testing Section
+        gr.Markdown("### 🧪 Test Raw Data Access")
+        gr.Markdown("*Test accessing comprehensive world data without HTML parsing*")
+        
+        with gr.Row():
+            test_raw_data_btn = gr.Button("Get Raw World Data", variant="secondary")
+            test_available_npcs_btn = gr.Button("Get Available NPCs", variant="secondary")
+        
+        raw_data_result = gr.JSON(label="Raw Data Output", visible=True)
+        
+        # Wire up handlers (simplified versions of original handlers)
+        register_ai_btn.click(
+            self._handle_register_ai_agent,
+            inputs=[ai_name],
+            outputs=[ai_result]
+        )
+        
+        execute_ai_btn.click(
+            self._handle_execute_ai_action,
+            inputs=[ai_action, ai_message],
+            outputs=[ai_result]
+        )
+        
+        test_raw_data_btn.click(
+            self._handle_test_raw_world_data,
+            inputs=[],
+            outputs=[raw_data_result]
+        )
+        
+        test_available_npcs_btn.click(
+            self._handle_test_available_npcs,
+            inputs=[],
+            outputs=[raw_data_result]
+        )
+      # =================================================================
+
     
+    def _handle_register_ai_agent(self, ai_name: str) -> str:
+        """Handle AI agent registration."""
+        if not ai_name or not ai_name.strip():
+            return "❌ Please enter a valid AI agent name"
+        
+        try:
+            agent_id = f"test_agent_{uuid.uuid4().hex[:8]}"
+            result = self.game_facade.register_ai_agent(agent_id, ai_name.strip())
+            
+            if result:
+                if not hasattr(self, 'registered_agents'):
+                    self.registered_agents = {}
+                self.registered_agents[agent_id] = ai_name.strip()
+                return f"✅ AI agent '{ai_name.strip()}' registered successfully!\nAgent ID: {agent_id}"
+            else:
+                return f"❌ Failed to register AI agent '{ai_name.strip()}'"
+        except Exception as e:
+            return f"❌ Error registering AI agent: {str(e)}"
+    
+    def _handle_execute_ai_action(self, action: str, message: str) -> str:
+        """Handle AI agent action execution."""
+        if not hasattr(self, 'registered_agents') or not self.registered_agents:
+            return "❌ No AI agents registered. Please register an AI agent first!"
+        
+        if not action:
+            return "❌ Please select an action to execute"
+        
+        try:
+            agent_id = list(self.registered_agents.keys())[0]
+            agent_name = self.registered_agents[agent_id]
+            
+            if action.startswith("move"):
+                direction = action.split()[1] if len(action.split()) > 1 else action
+                result = self.game_facade.move_ai_agent(agent_id, direction)
+                
+                if result.get("success"):
+                    position = result.get("position", {})
+                    return f"🤖 {agent_name} moved {direction} successfully!\nNew position: ({position.get('x', '?')}, {position.get('y', '?')})"
+                else:
+                    error_msg = result.get("error", "Movement failed")
+                    return f"❌ {agent_name} movement failed: {error_msg}"
+            elif action == "chat":
+                if not message or not message.strip():
+                    return "❌ Please enter a chat message"
+                
+                result = self.game_facade.ai_agent_chat(agent_id, message.strip())
+                
+                if result.get("success"):
+                    return f"💬 {agent_name} sent chat message: '{message.strip()}'"
+                else:
+                    error_msg = result.get("error", "Chat failed")
+                    return f"❌ {agent_name} chat failed: {error_msg}"
+            else:
+                return f"❓ Unknown action: {action}"
+        except Exception as e:
+            return f"❌ Error executing AI action: {str(e)}"
+        except Exception as e:
+            return f"❌ Error executing AI action: {str(e)}"
+    
+    def _handle_test_raw_world_data(self) -> Dict:
+        """Handle testing raw world data access."""
+        try:
+            raw_data = self.game_facade.get_raw_world_data()
+            return raw_data
+        except Exception as e:
+            return {"error": f"Failed to get raw world data: {str(e)}"}
+    
+    def _handle_test_available_npcs(self) -> List[Dict]:
+        """Handle testing available NPCs data access."""
+        try:
+            npcs_data = self.game_facade.get_available_npcs()
+            return npcs_data
+        except Exception as e:
+            return [{"error": f"Failed to get NPCs data: {str(e)}"}]
+ 
     def _create_architecture_content(self) -> None:
         """Create architecture documentation."""
         gr.Markdown("""

src/ui/improved_interface_demo.py

@@ -0,0 +1,138 @@
+"""
+Demo: How to use the Improved Interface Manager
+
+This file demonstrates how to integrate the improved interface manager
+into your MMORPG application for a better user experience.
+"""
+
+from improved_interface_manager import ImprovedInterfaceManager
+from .huggingface_ui import HuggingFaceUI
+from ..facades.game_facade import GameFacade
+
+
+def create_improved_interface():
+    """
+    Create an improved interface with enhanced UX.
+    
+    This replaces the original interface_manager with a cleaner,
+    more organized version that includes:
+    
+    1. ✅ Login in one line
+    2. ✅ Controls next to gameboard  
+    3. ✅ Better player stats form
+    4. ✅ Unified chat system
+    5. ✅ Consistent styling throughout
+    
+    Returns:
+        gradio.Blocks: The improved interface
+    """
+    
+    # Initialize the game facade (you'll need this from your existing setup)
+    game_facade = GameFacade()  # Use your existing game facade instance
+    
+    # Create the enhanced UI manager
+    ui = HuggingFaceUI(game_facade)
+    
+    # Create the improved interface manager
+    improved_manager = ImprovedInterfaceManager(game_facade, ui)
+    
+    # Create the interface
+    interface = improved_manager.create_interface()
+    
+    return interface
+
+
+def main():
+    """
+    Launch the improved interface.
+    
+    Replace your existing main() function with this to use the improved interface.
+    """
+    
+    # Create the improved interface
+    interface = create_improved_interface()
+    
+    # Launch with optimized settings
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        inbrowser=True,
+        show_error=True,
+        debug=True
+    )
+
+
+if __name__ == "__main__":
+    main()
+
+
+"""
+Key Improvements Made:
+
+1. 🎯 **One-Line Login**: 
+   - Moved player name input and join/leave buttons to a single horizontal row
+   - Added better visual styling with gradient background
+   - More compact and intuitive
+
+2. 🎮 **Controls Next to Gameboard**:
+   - Repositioned movement controls to be adjacent to the game world
+   - Compact 3x3 grid layout that doesn't take up too much space
+   - Enhanced visual feedback with hover effects
+
+3. 📊 **Enhanced Player Stats**:
+   - Replaced plain JSON display with styled HTML cards
+   - Added visual hierarchy with colors and gradients
+   - Shows health, level, position in a more readable format
+   - Dynamic status updates with better formatting
+
+4. 💬 **Unified Chat System**:
+   - Combined public and private chat in one clean interface
+   - Radio button toggle between chat modes
+   - Better visual separation and organization
+   - Maintains all original functionality
+
+5. 🎨 **Consistent Styling**:
+   - Enhanced CSS with modern gradients and shadows
+   - Consistent color scheme throughout
+   - Better spacing and typography
+   - Responsive design for different screen sizes
+   - Hover effects and smooth transitions
+   - Professional HuggingFace-inspired design
+
+6. 🚀 **Performance Optimizations**:
+   - Optimized game world size (650x450 vs 800x600)
+   - Better component organization
+   - Cleaner event handler structure
+
+7. 📱 **Better UX**:
+   - More intuitive layout with logical grouping
+   - Enhanced visual feedback
+   - Better error handling and status messages
+   - Improved accessibility
+
+Usage Instructions:
+
+1. Replace your existing interface_manager import:
+   ```python
+   # OLD:
+   from .interface_manager import InterfaceManager
+   
+   # NEW:
+   from .improved_interface_manager import ImprovedInterfaceManager
+   ```
+
+2. Update your interface creation:
+   ```python
+   # OLD:
+   manager = InterfaceManager(game_facade, ui)
+   
+   # NEW:
+   manager = ImprovedInterfaceManager(game_facade, ui)
+   ```
+
+3. All existing functionality is preserved - the interface just looks and feels better!
+
+The improved interface maintains 100% compatibility with your existing MCP server
+functionality while providing a much cleaner and more professional user experience.
+"""

src/ui/improved_interface_manager.py

@@ -0,0 +1,1068 @@
+"""
+Improved Interface Manager Module
+
+This module provides an enhanced, cleaner version of the interface manager
+with better layout, unified styling, and improved user experience.
+"""
+from typing import Dict, Any, List, Optional, Tuple
+from dataclasses import asdict
+import time
+import uuid
+import gradio as gr
+
+from ..core.game_engine import GameEngine
+from ..core.player import Player
+from ..core.world import GameWorld
+from ..facades.game_facade import GameFacade
+from .huggingface_ui import HuggingFaceUI
+
+
+class ImprovedInterfaceManager:
+    """Enhanced interface manager with cleaner design and better UX."""
+    
+    def __init__(self, game_facade: GameFacade, ui: HuggingFaceUI):
+        from ..core.game_engine import get_game_engine
+        self.game_engine = get_game_engine()
+        self.game_facade = game_facade
+        self.ui = ui
+        
+        # Interface state
+        self.interface = None
+        
+        # Auto-refresh timers
+        self.auto_refresh_interval = 2.0
+        
+        # Entity name to ID mapping for private chat
+        self.entity_name_to_id = {}
+        
+        # Current player tracking for enhanced features
+        self.current_player_id = None
+    
+    def create_interface(self) -> gr.Blocks:
+        """Create and configure the complete enhanced interface."""
+        self._create_enhanced_interface()
+        return self.interface
+    
+    def _create_enhanced_interface(self) -> None:
+        """Create the enhanced interface with improved layout and styling."""        # Enhanced CSS for better styling
+        enhanced_css = self.ui.custom_css + """
+        /* Enhanced styling for improved interface */
+        .login-section {
+            background: transparent;
+            color: #333;
+            padding: 15px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+            border: 1px solid #e9ecef;
+        }
+        
+        /* Remove gray gradient from join section */
+        .join-section {
+            background: transparent !important;
+        }
+        
+        .game-layout {
+            display: flex;
+            gap: 20px;
+            margin-top: 20px;
+        }
+        
+        .game-world-container {
+            flex: 3;
+            background: white;
+            border-radius: 12px;
+            padding: 15px;
+            box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+        }
+        
+        .controls-stats-panel {
+            background: #f8f9fa;
+            border: 2px solid #e9ecef;
+            border-radius: 12px;
+            padding: 15px;
+            margin-left: 15px;
+        }        .controls-stats-panel {
+            background: #f8f9fa;
+            border: 2px solid #e9ecef;
+            border-radius: 12px;
+            padding: 15px;
+            margin-left: 15px;
+        }
+        
+        .controls-grid {
+            display: grid;
+            grid-template-columns: repeat(3, 50px);
+            gap: 8px;
+            justify-content: center;
+            margin-top: 10px;
+        }
+        
+        .control-btn {
+            width: 50px;
+            height: 50px;
+            border-radius: 8px;
+            border: 2px solid #007bff;
+            background: #ffffff;
+            font-size: 16px;
+            font-weight: bold;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        
+        .control-btn:hover {
+            background: #007bff;
+            color: white;
+            transform: scale(1.05);
+        }
+        
+        .stats-panel {
+            flex: 1;
+            background: white;
+            border-radius: 12px;
+            padding: 20px;
+            box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+            margin-top: 20px;
+        }
+        
+        .player-stats-card {
+            background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 12px;
+            margin-bottom: 20px;
+            text-align: center;
+        }
+        
+        .stat-item {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 8px 0;
+            border-bottom: 1px solid rgba(255,255,255,0.2);
+        }
+        
+        .stat-label {
+            font-weight: bold;
+            opacity: 0.9;
+        }
+        
+        .stat-value {
+            background: rgba(255,255,255,0.2);
+            padding: 4px 8px;
+            border-radius: 6px;
+            font-weight: bold;
+        }
+        
+        .events-panel {
+            background: #fff3cd;
+            border: 1px solid #ffeaa7;
+            border-radius: 8px;
+            padding: 15px;
+            margin-top: 15px;
+        }
+        
+        .events-content {
+            font-size: 14px;
+            line-height: 1.5;
+        }
+        
+        .tip {
+            background: #d4edda;
+            border: 1px solid #c3e6cb;
+            border-radius: 6px;
+            padding: 10px;
+            margin-top: 10px;
+            font-size: 12px;
+        }
+        
+        .chat-unified {
+            background: white;
+            border-radius: 12px;
+            padding: 20px;
+            margin-top: 20px;
+            box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+        }
+        
+        .chat-tabs {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 15px;
+            border-bottom: 2px solid #e9ecef;
+            padding-bottom: 10px;
+        }
+        
+        .chat-tab {
+            padding: 8px 16px;
+            background: #f8f9fa;
+            border: 1px solid #e9ecef;
+            border-radius: 8px 8px 0 0;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        
+        .chat-tab.active {
+            background: #007bff;
+            color: white;
+            border-color: #007bff;
+        }
+        
+        .chat-tab:hover {
+            background: #e9ecef;
+        }
+        """
+        
+        # Get keyboard script for head injection
+        keyboard_js = self.ui.get_keyboard_script()
+        
+        with gr.Blocks(
+            title="🎮 MMORPG with MCP Integration",
+            theme=self.ui.theme,
+            css=enhanced_css,
+            head=keyboard_js
+        ) as interface:
+            
+            # Hero section
+            self.ui.create_hero_section()
+            
+            # Player state management
+            player_state = gr.State({})
+            
+            with gr.Tabs():
+                # Top-level Game World tab with nested sub-tabs
+                with gr.Tab("🌍 Game World"):
+                    with gr.Tabs():
+                        # Game Tab: world view, player status, movement
+                        with gr.Tab("🎮 Game"):
+
+                            gr.Markdown("**NPC Add-ons:** Walk near NPCs to unlock their features!")
+
+                            # One-line join section
+                            with gr.Group(elem_classes=["join-section"]):
+                                gr.Markdown("### 🎮 Join the Adventure")
+                                with gr.Row():
+                                    player_name = gr.Textbox(
+                                        label="Player Name",
+                                        placeholder="Enter your character name",
+                                        scale=4,
+                                        container=False
+                                    )
+                                    join_btn = gr.Button("Join Game 🎮", variant="primary", scale=1)
+                                    leave_btn = gr.Button("Leave Game 🚪", variant="secondary", scale=1)
+                        
+                            # Game layout and controls
+                            with gr.Row():
+                                # Left side: Game world spanning 4 columns for better visibility
+                                with gr.Column(scale=4):
+                                    game_view = gr.HTML(
+                                        value=self.ui._generate_world_html(900,600),
+                                        label="🌍 Game World",
+                                        elem_classes=["game-world-container"]
+                                    )
+                                
+                                # Right side: Combined controls and stats in 1 column
+                                with gr.Column(scale=1, elem_classes=["controls-stats-panel"]):
+                                    # Controls section
+                                    with gr.Group():
+                                        gr.Markdown("**🕹️ Controls**")
+                                        gr.Markdown("*WASD or Arrow Keys*")
+                                        
+                                        # Enhanced movement controls in grid
+                                        with gr.Row():
+                                            gr.HTML("")  # spacer
+                                            move_up = gr.Button("↑", elem_classes=["control-btn"])
+                                            gr.HTML("")  # spacer
+                                        with gr.Row():
+                                            move_left = gr.Button("←", elem_classes=["control-btn"])
+                                            action_btn = gr.Button("⚔️", elem_classes=["control-btn"], variant="secondary")
+                                            move_right = gr.Button("→", elem_classes=["control-btn"])
+                                        with gr.Row():
+                                            gr.HTML("")  # spacer
+                                            move_down = gr.Button("↓", elem_classes=["control-btn"])
+                                            gr.HTML("")  # spacer
+                                
+                                    # Player status panel below controls
+                                    player_info = gr.HTML(label="Player Information")
+                        
+                        # Chat Tab: unified public and private chat
+                        with gr.Tab("💬 Chat"):
+                            with gr.Group(elem_classes=["chat-unified"]):
+                                gr.Markdown("### 💬 Communication Hub")
+                                
+                                # Chat type selector
+                                with gr.Row():
+                                    chat_mode = gr.Radio(
+                                        choices=["🌍 Public Chat", "🔒 Private Messages"],
+                                        value="🌍 Public Chat",
+                                        label="Chat Mode",
+                                        scale=2
+                                    )
+                                    auto_refresh_enabled = gr.Checkbox(
+                                        label="Auto-refresh (2s)",
+                                        value=True,
+                                        scale=1
+                                    )
+                                
+                                public_chat_group = gr.Group()
+                                with public_chat_group:
+                                    chat_display = gr.Chatbot(
+                                        label="💬 Game Chat",
+                                        height=250,
+                                        type='messages',
+                                        value=[{"role": "assistant", "content": "Welcome! Join the game to start chatting!"}]
+                                    )
+                                    
+                                    with gr.Row():
+                                        chat_input = gr.Textbox(
+                                            placeholder="Type your message... (use /help for commands)",
+                                            scale=4,
+                                            container=False
+                                        )
+                                        chat_send = gr.Button("Send", scale=1, variant="primary")
+                                
+                                private_chat_group = gr.Group(visible=False)
+                                with private_chat_group:
+                                    proximity_info = gr.HTML(
+                                        value="<div style='text-align: center; color: #666;'>🔍 Move near NPCs or players to chat privately</div>"
+                                    )
+                                    
+                                    nearby_entities = gr.Dropdown(
+                                        label="💬 Start new chat with",
+                                        choices=[],
+                                        interactive=True
+                                    )
+                                    
+                                    with gr.Row():
+                                        start_chat_btn = gr.Button("Start Chat", variant="primary", scale=1)
+                                        clear_all_tabs_btn = gr.Button("Clear All", variant="secondary", scale=1)
+                                    
+                                    # Chat tabs and current conversation
+                                    chat_tabs_state = gr.State({})
+                                    active_tabs_display = gr.HTML(
+                                        value="<div style='text-align: center; color: #666; padding: 10px;'>No active chats</div>"
+                                    )
+                                    
+                                    current_chat_display = gr.Chatbot(
+                                        label="🔒 Private Messages",
+                                        height=200,
+                                        type='messages',
+                                        value=[],
+                                        visible=False
+                                    )
+                                    
+                                    with gr.Row(visible=False) as chat_input_row:
+                                        private_message_input = gr.Textbox(
+                                            placeholder="Type private message...",
+                                            scale=4,
+                                            container=False
+                                        )
+                                        private_send_btn = gr.Button("Send", scale=1, variant="secondary")
+                        
+                        # Status Tab: online players and world events
+                        with gr.Tab("📊 Status"):
+                            online_players = gr.Dataframe(
+                                headers=["Name","Type","Level"],
+                                label="👥 Online Players",
+                                elem_classes=["players-table"]
+                            )
+                            
+                            world_events = gr.HTML(label="Game Events")
+            
+                # NPC Add-ons Tab
+                with gr.Tab("🤖 NPC Add-ons"):
+                    self.ui._create_npc_addons_content()
+                
+                # Plugin System Tab
+                with gr.Tab("🔌 Plugin System"):
+                    gr.Markdown("### 🔧 Plugin Manager")
+                    refresh_plugins_btn = gr.Button("🔄 Refresh Plugins", variant="primary")
+                    reload_all_btn = gr.Button("🔄 Reload All", variant="secondary")
+                    plugin_status = gr.JSON(value={
+                        "total_plugins": 0,
+                        "active_plugins": 0,
+                        "failed_plugins": 0,
+                        "last_scan": "Never"
+                    }, label="Plugin Status")
+                    # Wire up plugin manager actions
+                    refresh_plugins_btn.click(
+                        self._handle_refresh_plugins,
+                        inputs=[],
+                        outputs=[plugin_status]
+                    )
+                    reload_all_btn.click(
+                        self._handle_reload_all_plugins,
+                        inputs=[],
+                        outputs=[plugin_status]
+                    )
+                
+                # MCP Integration Tab
+                with gr.Tab("🔗 MCP Integration"):
+                    self.ui._create_mcp_integration_content()
+                
+                # AI Agent Testing Tab
+                with gr.Tab("🧪 AI Agent Testing"):
+                    self._create_ai_testing_tab()
+                
+                # Architecture Tab
+                with gr.Tab("🏗️ Architecture"):
+                    self.ui._create_architecture_content()
+            
+
+
+            # =================================================================
+            # EVENT HANDLERS
+            # =================================================================
+            
+            # Chat mode switching
+            def switch_chat_mode(mode):
+                if mode == "🌍 Public Chat":
+                    # Show public chat, hide private chat and input row
+                    return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+                else:
+                    # Hide public chat, show private chat and input row
+                    return gr.update(visible=False), gr.update(visible=True), gr.update(visible=True)
+
+            chat_mode.change(
+                switch_chat_mode,
+                inputs=[chat_mode],
+                outputs=[public_chat_group, private_chat_group, chat_input_row]
+            )
+            
+            # Join/Leave game handlers
+            join_btn.click(
+                self._handle_join_game,
+                inputs=[player_name, player_state],
+                outputs=[player_state, player_info, online_players, game_view]
+            )
+            
+            leave_btn.click(
+                self._handle_leave_game,
+                inputs=[player_state],
+                outputs=[player_state, player_info, online_players, game_view]
+            )
+            
+            # Movement handlers
+            move_up.click(
+                self._handle_movement,
+                inputs=[gr.State("up"), player_state],
+                outputs=[player_state, game_view, world_events]
+            )
+            
+            move_down.click(
+                self._handle_movement,
+                inputs=[gr.State("down"), player_state],
+                outputs=[player_state, game_view, world_events]
+            )
+            
+            move_left.click(
+                self._handle_movement,
+                inputs=[gr.State("left"), player_state],
+                outputs=[player_state, game_view, world_events]
+            )
+            
+            move_right.click(
+                self._handle_movement,
+                inputs=[gr.State("right"), player_state],
+                outputs=[player_state, game_view, world_events]
+            )
+            
+            action_btn.click(
+                self._handle_action,
+                inputs=[player_state],
+                outputs=[world_events]
+            )
+            
+            # Chat handlers
+            chat_send.click(
+                self._handle_chat_message,
+                inputs=[chat_input, player_state],
+                outputs=[chat_display, chat_input]
+            )
+            
+            chat_input.submit(
+                self._handle_chat_message,
+                inputs=[chat_input, player_state],
+                outputs=[chat_display, chat_input]
+            )
+            
+            # Private chat handlers
+            start_chat_btn.click(
+                self._handle_start_chat,
+                inputs=[nearby_entities, chat_tabs_state, player_state],
+                outputs=[chat_tabs_state, active_tabs_display, current_chat_display, chat_input_row]
+            )
+            
+            private_send_btn.click(
+                self._handle_private_message,
+                inputs=[private_message_input, chat_tabs_state, player_state],
+                outputs=[current_chat_display, private_message_input]
+            )
+            
+            clear_all_tabs_btn.click(
+                self._handle_clear_all_chats,
+                inputs=[chat_tabs_state],
+                outputs=[chat_tabs_state, active_tabs_display, current_chat_display, chat_input_row]
+            )
+            
+            # Auto-refresh handlers
+            refresh_timer = gr.Timer(value=self.auto_refresh_interval)
+            refresh_timer.tick(
+                self._auto_refresh_game_state,
+                inputs=[player_state, auto_refresh_enabled],
+                outputs=[player_info, online_players, game_view, proximity_info, nearby_entities, 
+                        private_chat_group, chat_display, world_events]
+            )
+        
+        self.interface = interface
+    
+    def _create_ai_testing_tab(self):
+        """Create enhanced AI testing tab."""
+        gr.Markdown("## 🧪 Test AI Agent Integration")
+        gr.Markdown("*Use this to simulate AI agent connections for testing*")
+        
+        with gr.Row():
+            ai_name = gr.Textbox(
+                label="AI Agent Name",
+                placeholder="Claude the Explorer",
+                scale=3
+            )
+            register_ai_btn = gr.Button("Register AI Agent", variant="primary", scale=1)
+        
+        with gr.Row():
+            ai_action = gr.Dropdown(
+                choices=["move up", "move down", "move left", "move right", "chat"],
+                label="AI Action",
+                scale=2
+            )
+            ai_message = gr.Textbox(
+                label="AI Message (for chat)",
+                placeholder="Hello humans!",
+                scale=3
+            )
+        
+        execute_ai_btn = gr.Button("Execute AI Action", variant="secondary")
+        ai_result = gr.Textbox(label="AI Action Result", interactive=False, lines=5)
+        
+        # Raw Data Testing Section
+        gr.Markdown("### 🧪 Test Raw Data Access")
+        gr.Markdown("*Test accessing comprehensive world data without HTML parsing*")
+        
+        with gr.Row():
+            test_raw_data_btn = gr.Button("Get Raw World Data", variant="secondary")
+            test_available_npcs_btn = gr.Button("Get Available NPCs", variant="secondary")
+        
+        raw_data_result = gr.JSON(label="Raw Data Output", visible=True)
+        
+        # Wire up handlers (simplified versions of original handlers)
+        register_ai_btn.click(
+            self._handle_register_ai_agent,
+            inputs=[ai_name],
+            outputs=[ai_result]
+        )
+        
+        execute_ai_btn.click(
+            self._handle_execute_ai_action,
+            inputs=[ai_action, ai_message],
+            outputs=[ai_result]
+        )
+        
+        test_raw_data_btn.click(
+            self._handle_test_raw_world_data,
+            inputs=[],
+            outputs=[raw_data_result]
+        )
+        
+        test_available_npcs_btn.click(
+            self._handle_test_available_npcs,
+            inputs=[],
+            outputs=[raw_data_result]
+        )
+      # =================================================================
+    # EVENT HANDLER METHODS (Reusing from original interface manager)
+    # =================================================================
+    
+    def _handle_join_game(self, name: str, current_state: Dict) -> Tuple[Dict, str, List[List[str]], str]:
+        """Handle player joining the game with enhanced UI feedback."""
+        if not name or not name.strip():
+            return current_state, self._create_error_stats_html("Please enter a valid name"), [], self.ui._generate_world_html(900, 600)
+        
+        player_id = self.game_facade.join_game(name.strip())
+        if not player_id:
+            return current_state, self._create_error_stats_html("Failed to join game"), [], self.ui._generate_world_html(900, 600)
+        
+        current_state.update({"player_id": player_id, "joined": True, "name": name.strip()})
+        self.current_player_id = player_id
+          # Enhanced player stats HTML
+        stats_html = self._create_player_stats_html(player_id, name.strip())
+        rows = self._get_online_players_data()
+        world_html = self._generate_world_html_with_players()
+        
+        return current_state, stats_html, rows, world_html
+    
+    def _handle_leave_game(self, current_state: Dict) -> Tuple[Dict, str, List[List[str]], str]:
+        """Handle player leaving the game with enhanced UI feedback."""
+        player_id = current_state.get("player_id")
+        success = self.game_facade.leave_game(player_id)
+        
+        new_state: Dict = {}
+        self.current_player_id = None
+        
+        stats_html = self._create_default_stats_html()
+        rows = self._get_online_players_data()
+        world_html = self._generate_world_html_with_players()
+        
+        return new_state, stats_html, rows, world_html
+    
+    def _handle_movement(self, direction: str, current_state: Dict) -> Tuple[Dict, str, str]:
+        """Handle player movement with enhanced feedback."""
+        if not current_state.get("joined"):
+            return current_state, self._generate_world_html_with_players(), self._create_events_html("Join the game to move!")
+        
+        try:
+            player_id = current_state.get("player_id")
+            success, new_position, events = self.game_facade.move_player(player_id, direction)
+            
+            if success:
+                current_state.update(new_position)
+                world_html = self._generate_world_html_with_players()
+                events_html = self._create_events_html(events or f"Moved {direction}")
+                return current_state, world_html, events_html
+            else:
+                events_html = self._create_events_html(f"Cannot move {direction} - blocked!")
+                return current_state, self._generate_world_html_with_players(), events_html
+                
+        except Exception as e:
+            return current_state, self._generate_world_html_with_players(), self._create_events_html(f"Movement error: {str(e)}")
+    
+    def _handle_action(self, current_state: Dict) -> str:
+        """Handle special action button with enhanced feedback."""
+        if not current_state.get("joined"):
+            return self._create_events_html("Join the game to use actions!")
+        
+        try:
+            player_id = current_state.get("player_id")
+            result = self.game_facade.handle_action(player_id)
+            return self._create_events_html(result)        
+        except Exception as e:
+            return self._create_events_html(f"Action error: {str(e)}")
+    
+    def _handle_chat_message(self, message: str, current_state: Dict) -> Tuple[List[Dict], str]:
+        """Handle public chat messages."""
+        if not message or not message.strip() or not current_state.get("joined"):
+            return [], ""
+        
+        try:
+            player_id = current_state.get("player_id")
+            self.game_facade.send_chat_message(player_id, message.strip())
+            history = self.game_facade.get_chat_history(20)
+            formatted = self._format_chat_messages(history)
+            return formatted, ""
+        except Exception:
+            return [{"role": "assistant", "content": "Chat error"}], ""
+    
+    def _handle_start_chat(self, entity_selection: str, chat_tabs_state: Dict, current_state: Dict):
+        """Handle starting a private chat - proper implementation."""
+        if not entity_selection or not current_state.get("joined"):
+            return chat_tabs_state, "", gr.update(visible=False), gr.update(visible=False)
+        
+        try:
+            # Convert display name back to entity ID using the stored mapping
+            entity_id = self.entity_name_to_id.get(entity_selection, entity_selection)
+            entity_name = entity_selection  # We already have the display name
+            
+            if entity_id not in chat_tabs_state:
+                chat_tabs_state[entity_id] = {
+                    "name": entity_name,
+                    "active": True,
+                    "pinned": False,
+                    "unread": 0
+                }
+            
+            # Set as active
+            for tab_id in chat_tabs_state:
+                chat_tabs_state[tab_id]["active"] = (tab_id == entity_id)
+            
+            # Get chat messages for this entity
+            player_id = current_state.get("player_id")
+            messages = self.game_facade.get_private_messages(player_id, entity_id)
+            tabs_html = self._generate_chat_tabs_html(chat_tabs_state)
+            return chat_tabs_state, gr.update(value=tabs_html), gr.update(value=messages, visible=True), gr.update(visible=True)
+            
+        except Exception as e:
+            return chat_tabs_state, gr.update(value=f"Error: {str(e)}"), gr.update(visible=False), gr.update(visible=False)
+
+    def _handle_private_message(self, message: str, chat_tabs_state: Dict, current_state: Dict):
+        """Handle private chat messages - proper implementation."""
+        # Validate input and state
+        if not message or not message.strip() or not current_state.get("joined"):
+            return [], ""
+        
+        # Determine active entity for private chat
+        entity_id = next((eid for eid, info in chat_tabs_state.items() if info.get("active")), None)
+        if not entity_id:
+            return [], ""
+        
+        print(f"[ImprovedInterfaceManager] Sending private message from {current_state.get('player_id')} to {entity_id}: '{message.strip()}'")
+        
+        # Send private message via game facade
+        player_id = current_state.get("player_id")
+        player_name = current_state.get("name", "Unknown")  # Get player name from state
+        success = self.game_facade.send_private_message(player_id, player_name, entity_id, message.strip())
+        
+        if success:
+            # Fetch updated messages
+            messages = self.game_facade.get_private_messages(player_id, entity_id)
+            # Format messages for Gradio Chatbot
+            formatted = []
+            for msg in messages[-20:]:  # last 20 messages
+                # Determine role based on sender_id vs current player
+                role = "user" if msg.get("sender_id") == player_id else "assistant"
+                # Convert newlines to HTML breaks for proper display
+                message_content = msg.get('message', '').replace('\n', '<br>')
+                content = f"[{msg.get('timestamp', '')}] {msg.get('sender', 'Unknown')}: {message_content}"
+                formatted.append({"role": role, "content": content})
+            
+            print(f"[ImprovedInterfaceManager] Formatted {len(formatted)} private messages for display")
+            return formatted, ""
+        else:
+            print(f"[ImprovedInterfaceManager] Failed to send private message")
+            return [], ""
+
+    def _handle_clear_all_chats(self, chat_tabs_state: Dict):
+        """Handle clearing all private chat tabs - proper implementation."""
+        chat_tabs_state.clear()
+        tabs_html = self._generate_chat_tabs_html(chat_tabs_state)
+        return chat_tabs_state, tabs_html, gr.update(visible=False), gr.update(visible=False)
+    
+    def _handle_register_ai_agent(self, ai_name: str) -> str:
+        """Handle AI agent registration."""
+        if not ai_name or not ai_name.strip():
+            return "❌ Please enter a valid AI agent name"
+        
+        try:
+            agent_id = f"test_agent_{uuid.uuid4().hex[:8]}"
+            result = self.game_facade.register_ai_agent(agent_id, ai_name.strip())
+            
+            if result:
+                if not hasattr(self, 'registered_agents'):
+                    self.registered_agents = {}
+                self.registered_agents[agent_id] = ai_name.strip()
+                return f"✅ AI agent '{ai_name.strip()}' registered successfully!\nAgent ID: {agent_id}"
+            else:
+                return f"❌ Failed to register AI agent '{ai_name.strip()}'"
+        except Exception as e:
+            return f"❌ Error registering AI agent: {str(e)}"
+    
+    def _handle_execute_ai_action(self, action: str, message: str) -> str:
+        """Handle AI agent action execution."""
+        if not hasattr(self, 'registered_agents') or not self.registered_agents:
+            return "❌ No AI agents registered. Please register an AI agent first!"
+        
+        if not action:
+            return "❌ Please select an action to execute"
+        
+        try:
+            agent_id = list(self.registered_agents.keys())[0]
+            agent_name = self.registered_agents[agent_id]
+            
+            if action.startswith("move"):
+                direction = action.split()[1] if len(action.split()) > 1 else action
+                result = self.game_facade.move_ai_agent(agent_id, direction)
+                
+                if result.get("success"):
+                    position = result.get("position", {})
+                    return f"🤖 {agent_name} moved {direction} successfully!\nNew position: ({position.get('x', '?')}, {position.get('y', '?')})"
+                else:
+                    error_msg = result.get("error", "Movement failed")
+                    return f"❌ {agent_name} movement failed: {error_msg}"
+            elif action == "chat":
+                if not message or not message.strip():
+                    return "❌ Please enter a chat message"
+                
+                result = self.game_facade.ai_agent_chat(agent_id, message.strip())
+                
+                if result.get("success"):
+                    return f"💬 {agent_name} sent chat message: '{message.strip()}'"
+                else:
+                    error_msg = result.get("error", "Chat failed")
+                    return f"❌ {agent_name} chat failed: {error_msg}"
+            else:
+                return f"❓ Unknown action: {action}"
+        except Exception as e:
+            return f"❌ Error executing AI action: {str(e)}"
+        except Exception as e:
+            return f"❌ Error executing AI action: {str(e)}"
+    
+    def _handle_test_raw_world_data(self) -> Dict:
+        """Handle testing raw world data access."""
+        try:
+            raw_data = self.game_facade.get_raw_world_data()
+            return raw_data
+        except Exception as e:
+            return {"error": f"Failed to get raw world data: {str(e)}"}
+    
+    def _handle_test_available_npcs(self) -> List[Dict]:
+        """Handle testing available NPCs data access."""
+        try:
+            npcs_data = self.game_facade.get_available_npcs()
+            return npcs_data
+        except Exception as e:
+            return [{"error": f"Failed to get NPCs data: {str(e)}"}]
+    
+    def _handle_refresh_plugins(self):
+        """Refresh plugin list and status metrics."""
+        from datetime import datetime
+        plugin_ids = self.game_facade.get_loaded_plugins()
+        active = 0
+        failed = 0
+        for pid in plugin_ids:
+            status = self.game_facade.get_plugin_status(pid) or {}
+            if status.get('enabled', False):
+                active += 1
+            else:
+                failed += 1
+        return {
+            'total_plugins': len(plugin_ids),
+            'active_plugins': active,
+            'failed_plugins': failed,
+            'last_scan': datetime.now().isoformat()
+        }
+
+    def _handle_reload_all_plugins(self):
+        """Hot-reload all discovered plugins."""
+        plugin_ids = self.game_facade.get_loaded_plugins()
+        for pid in plugin_ids:
+            try:
+                self.game_facade.reload_plugin(pid)
+            except Exception:
+                pass
+        # return refreshed status
+        return self._handle_refresh_plugins()
+    
+    def _auto_refresh_game_state(self, current_state: Dict, auto_refresh: bool):
+        """Auto-refresh game state with enhanced UI updates."""
+        if not auto_refresh or not current_state.get("joined"):
+            return (gr.update(),) * 8
+        
+        try:
+            player_id = current_state.get("player_id")
+            player_name = current_state.get("name", "Unknown")
+            
+            # Enhanced player stats
+            stats_html = self._create_player_stats_html(player_id, player_name)
+            online_players_data = self._get_online_players_data()
+            world_html = self._generate_world_html_with_players()
+            
+            # Proximity and chat info
+            proximity_html, nearby_choices, show_private_chat = self._get_proximity_info(player_id)
+            chat_history = self.game_facade.get_chat_history(20)
+            formatted_chat = self._format_chat_messages(chat_history)
+            events_html = self._get_formatted_world_events()
+            
+            return (
+                gr.update(value=stats_html),
+                gr.update(value=online_players_data),
+                gr.update(value=world_html),
+                gr.update(value=proximity_html),
+                gr.update(choices=nearby_choices),
+                gr.update(visible=show_private_chat),
+                gr.update(value=formatted_chat),
+                gr.update(value=events_html),
+            )
+        except Exception as e:
+            print(f"Auto-refresh error: {e}")
+            return (gr.update(),) * 8
+    
+    # =================================================================
+    # HELPER METHODS FOR ENHANCED UI
+    # =================================================================
+    
+    def _create_player_stats_html(self, player_id: str, player_name: str) -> str:
+        """Create enhanced player stats HTML."""
+        try:
+            player_data = self.game_facade.get_player_stats(player_id)
+            
+            return f"""
+            <div class="player-stats-card">
+                <h3>🧝‍♂️ {player_name}</h3>
+                <div class="stat-item">
+                    <span class="stat-label">Status:</span>
+                    <span class="stat-value">Online</span>
+                </div>
+                <div class="stat-item">
+                    <span class="stat-label">Level:</span>
+                    <span class="stat-value">{player_data.get('level', 1)}</span>
+                </div>
+                <div class="stat-item">
+                    <span class="stat-label">Health:</span>
+                    <span class="stat-value">{player_data.get('hp', 100)}/{player_data.get('max_hp', 100)}</span>
+                </div>
+                <div class="stat-item">
+                    <span class="stat-label">XP:</span>
+                    <span class="stat-value">{player_data.get('experience', 0)}</span>
+                </div>
+                <div class="stat-item">
+                    <span class="stat-label">Gold:</span>
+                    <span class="stat-value">{player_data.get('gold', 0)}</span>
+                </div>
+                <div class="stat-item">
+                    <span class="stat-label">Position:</span>
+                    <span class="stat-value">{player_data.get('position', '(0,0)')}</span>
+                </div>
+            </div>
+            """
+        except Exception:
+            return self._create_default_stats_html()
+    
+    def _create_default_stats_html(self) -> str:
+        """Create default stats HTML when not connected."""
+        return """
+        <div class="player-stats-card">
+            <h3>🧝‍♂️ Player Stats</h3>
+            <div class="stat-item">
+                <span class="stat-label">Status:</span>
+                <span class="stat-value">Not connected</span>
+            </div>
+            <div class="info-text" style="margin-top: 10px; opacity: 0.9;">
+                Join the game to see your stats
+            </div>
+        </div>
+        """
+    
+    def _create_error_stats_html(self, error_message: str) -> str:
+        """Create error stats HTML."""
+        return f"""
+        <div class="player-stats-card" style="background: linear-gradient(135deg, #f44336 0%, #d32f2f 100%);">
+            <h3>❌ Error</h3>
+            <div class="info-text" style="margin-top: 10px; opacity: 0.9;">
+                {error_message}
+            </div>
+        </div>
+        """
+    
+    def _create_events_html(self, events_text: str) -> str:
+        """Create formatted events HTML."""
+        return f"""
+        <div class="events-panel">
+            <h4>🌍 World Events</h4>
+            <div class="events-content">
+                <p>{events_text}</p>
+                <div class="tip">
+                    💡 <strong>Tip:</strong> Walk near NPCs (📮🏪🌤️) to interact!<br>
+                    Then visit the 'NPC Add-ons' tab to use their features.
+                </div>
+            </div>
+        </div>
+        """
+    
+    def _generate_chat_tabs_html(self, chat_tabs_state: Dict) -> str:
+        """Generate HTML for chat tabs display."""
+        if not chat_tabs_state:
+            return "<div style='text-align: center; color: #666; padding: 10px;'>No active chats</div>"
+        
+        tabs_html = "<div style='display: flex; flex-wrap: wrap; gap: 5px; padding: 5px;'>"
+        for entity_id, tab_info in chat_tabs_state.items():
+            active_class = "active" if tab_info.get('active') else ""
+            pin_icon = "📌" if tab_info.get('pinned') else ""
+            unread_badge = f" ({tab_info.get('unread', 0)})" if tab_info.get('unread', 0) > 0 else ""
+            
+            tabs_html += f'''
+            <div class="chat-tab {active_class}" 
+                 style="display: flex; align-items: center; gap: 5px; padding: 8px 12px; 
+                        background: {'#007bff' if tab_info.get('active') else '#f8f9fa'}; 
+                        color: {'white' if tab_info.get('active') else '#333'}; 
+                        border-radius: 8px; border: 1px solid #e9ecef;"
+                 title="Entity ID: {entity_id}">
+                <span>{tab_info['name']}{unread_badge}</span>
+                {pin_icon}
+                <span style="color: #f44336; font-weight: bold; cursor: pointer; margin-left: 5px;" title="Close tab">×</span>
+            </div>
+            '''
+        tabs_html += "</div>"
+        return tabs_html
+
+    # Import helper methods from original interface manager
+    def _get_online_players_data(self):
+        """Get online players data - imported from original."""
+        try:
+            players_data = []
+            for player in self.game_facade.get_all_players().values():                players_data.append([
+                    player.name,
+                    "🤖 AI" if player.type == "ai_agent" else "👤 Human",
+                    str(player.level)
+                ])
+            return players_data
+        except Exception:
+            return []
+    
+    def _generate_world_html_with_players(self):
+        """Generate world HTML with enhanced size for better visibility."""
+        return self.ui._generate_world_html(900, 600)
+    
+    def _format_chat_messages(self, messages):
+        """Format chat messages - imported from original."""
+        formatted = []
+        for msg in messages[-20:]:
+            role = "assistant" if msg.get("sender") == "System" else "user"
+            message_content = msg.get('message', '').replace('\n', '<br>')
+            content = f"[{msg.get('timestamp', '')}] {msg.get('sender', 'Unknown')}: {message_content}"
+            formatted.append({"role": role, "content": content})
+        return formatted
+    
+    def _get_proximity_info(self, player_id):
+        """Get proximity info - imported from original."""
+        try:
+            proximity_data = self.game_facade.get_proximity_info(player_id)
+            nearby_entities = proximity_data.get("nearby_entities", [])
+            
+            if nearby_entities:
+                proximity_html = f"<div style='color: #4caf50;'>📡 Found {len(nearby_entities)} nearby entities</div>"
+                choices = []
+                self.entity_name_to_id = {}
+                
+                for entity in nearby_entities:
+                    entity_id = entity['id']
+                    entity_name = self._get_entity_name(entity_id)
+                    self.entity_name_to_id[entity_name] = entity_id
+                    choices.append(entity_name)
+                
+                return proximity_html, choices, True
+            else:
+                proximity_html = "<div style='color: #666;'>🔍 Move near NPCs or players to chat privately</div>"
+                return proximity_html, [], False
+        except Exception as e:
+            return f"<div style='color: #f44336;'>Error: {str(e)}</div>", [], False
+    
+    def _get_entity_name(self, entity_id):
+        """Get entity name - imported from original."""
+        try:
+            world = self.game_engine.get_world()
+            
+            npc = world.npcs.get(entity_id)
+            if npc:
+                return npc.get("name", entity_id)
+            
+            player = world.players.get(entity_id)
+            if player:
+                return player.name
+            
+            return entity_id
+        except Exception:
+            return entity_id
+    
+    def _get_formatted_world_events(self):
+        """Get formatted world events - imported from original."""
+        try:
+            world_events = self.game_facade.get_world_events()
+            if not world_events:
+                return self._create_events_html("No recent world events...")
+            
+            formatted_events = []
+            for event in world_events[-10:]:
+                timestamp = event.get('timestamp', '')
+                event_text = event.get('event', '')
+                formatted_events.append(f"[{timestamp}] {event_text}")
+            
+            return self._create_events_html("\\n".join(formatted_events))
+        except Exception as e:
+            print(f"Error formatting world events: {e}")
+            return self._create_events_html("Error loading world events...")

src/ui/interface_manager.py

@@ -204,7 +204,6 @@ class InterfaceManager:
                                         container=False
                                     )
                                     private_send_btn = gr.Button("Send", scale=1, variant="secondary")
-                
                 # Documentation Tab
                 with gr.Tab("📚 Documentation"):
                     self.ui._create_documentation_content()
@@ -215,7 +214,8 @@ class InterfaceManager:
                 
                 # Plugin System Tab
                 with gr.Tab("🔌 Plugin System"):
-                    self.ui._create_plugin_system_content()                # MCP Integration Tab
+                    self.ui._create_plugin_system_content()
+                # MCP Integration Tab
                 with gr.Tab("🔗 MCP Integration"):
                     self.ui._create_mcp_integration_content()