Remove deprecated conversation management and UI components from the archive

DHAKA_ROUTE_VERIFICATION.md

@@ -1,150 +0,0 @@
-# Dhaka Route Verification: Ahsanullah University → Tejgaon College
-
-## Your Route Details
-
-**Origin:** Ahsanullah University of Science and Technology (141, &142 Love Rd, Dhaka 1208)
-**Destination:** Tejgaon College (16 Indira Rd, Dhaka 1215)
-**Distance:** 2.5 km
-**Vehicle:** Car
-
-### Your Algorithm's Estimate
-- **Base Duration:** 19 minutes (at 8 km/h)
-- **With Traffic:** 57 minutes
-- **Traffic Delay:** +200% (Severe)
-- **Traffic Status:** 🔴 SEVERE - Heavy congestion
-
-## Real-World Data from Research Studies
-
-### Current Dhaka Traffic Speeds (2023-2025 Studies)
-
-According to recent traffic studies and research papers:
-
-1. **Average speed in Dhaka (2023):** **4.8 km/h**
-   - Source: Business Standard, April 2023
-
-2. **Peak hour speeds:** **5 km/h or less**
-   - Some areas drop below 10 km/h during rush hours
-   - Source: BUET Accident Research Institute
-
-3. **Historical comparison:**
-   - 1990s: 25 km/h average
-   - 2005: 21 km/h average
-   - 2025: **4.8 km/h average** (slower than walking speed!)
-
-### Tejgaon Area Specific Information
-
-**Critical Finding:** Tejgaon is specifically mentioned as a **major congestion hotspot** in Dhaka.
-
-From research studies:
-- "Traffic has increased at Bijoy Sarani, **Tejgaon**, Shat Rasta and adjacent areas"
-- "The pressure of traffic at **Farmgate**, Bijoy Sarani and Tejgaon is not likely to lessen"
-- Tejgaon College is located at **Farmgate** - one of Dhaka's worst congestion points
-
-## Calculated Real-World Time
-
-For 2.5 km in Tejgaon/Farmgate area:
-
-**At 4.8 km/h (current Dhaka average):**
-2.5 km ÷ 4.8 km/h = **31 minutes**
-
-**At 5 km/h (peak hours):**
-2.5 km ÷ 5 km/h = **30 minutes**
-
-## Comparison
-
-| Method | Time Estimate | Accuracy |
-|--------|---------------|----------|
-| **Your Algorithm** | 57 minutes | ⚠️ 2x too slow |
-| **Real-World Data** | 30-31 minutes | ✅ Based on studies |
-| **Walking Speed** | ~30 minutes | (at 5 km/h) |
-
-## Analysis
-
-### Why the Discrepancy?
-
-Your algorithm is **conservative but over-estimates** by about 2x. Here's why:
-
-1. **Base Speed Issue:**
-   - Your algorithm: 8 km/h base speed
-   - Reality: 4.8 km/h actual average
-   - Your base is actually FASTER than reality!
-
-2. **But Then You Add Too Many Delays:**
-   - Traffic signals: +11 minutes
-   - Intersections: +1.4 minutes
-   - Congestion multiplier: +31 minutes (150% extra)
-   - **Total delays: +43 minutes**
-
-3. **The Problem:**
-   - Real Dhaka traffic (4.8 km/h) already includes all these factors
-   - Your algorithm applies them AGAIN on top of 8 km/h base
-   - This double-counts the delays
-
-### What This Means
-
-**Real Dhaka drivers experience:**
-- Constant crawling at 4.8 km/h
-- This already includes stopped time at signals, intersections, congestion
-- The 4.8 km/h is the "all-in" effective speed
-
-**Your algorithm assumes:**
-- 8 km/h when moving
-- PLUS separate time stopped at signals
-- PLUS separate congestion delays
-- Result: Double-counting leads to 2x estimate
-
-## Verdict
-
-### ✅ Your Algorithm is **Directionally Correct** but **Too Conservative**
-
-**Positive:**
-- Correctly identified Dhaka as heavy traffic city
-- Correctly detected peak hours
-- Better to over-estimate than under-estimate for delivery planning
-
-**Needs Adjustment:**
-- Your 57-minute estimate vs real 30-31 minutes
-- Off by about **26 minutes (2x)**
-
-### Recommendation for Calibration
-
-For Dhaka peak hours, instead of:
-```
-Base speed: 8 km/h
-+ Signal delays
-+ Intersection delays
-+ Congestion multiplier (2.5x)
-= 57 minutes
-```
-
-Should be:
-```
-Effective all-in speed: 5 km/h
-(No additional multipliers - they're already baked in)
-= 30 minutes
-```
-
-## Conclusion
-
-**Your estimate: 57 minutes ⚠️**
-**Real-world: 30-31 minutes ✅**
-**Accuracy: Over-estimated by 85% (almost 2x)**
-
-However, this is actually **safer for delivery operations** than under-estimating. It's better to tell drivers "57 minutes" and have them arrive in 30 minutes than to say "30 minutes" and have them late.
-
-For **operational planning** (not real-time navigation), your conservative estimate provides a buffer for:
-- Unexpected delays
-- Accidents or road closures
-- Worst-case scenarios
-
-**Bottom line:** Your algorithm works, but could be fine-tuned to be more accurate. The 2x buffer might be useful for SLA planning but should be documented as conservative.
-
----
-
-## Sources
-
-1. "City speed drops to 4.5kmph from 21kmph in a decade" - The Business Standard
-2. "Dhaka traffic at 4.0km per hour!" - The Financial Express
-3. "Real Time Traffic Congestion Analyzer of Dhaka City" - BUET Study
-4. "Dhaka's Farmgate: The new hub of traffic congestion" - Prothom Alo
-5. Traffic in Dhaka - Numbeo (crowd-sourced traffic data)

ROUTING_VERIFICATION_RESULTS.md

@@ -1,174 +0,0 @@
-# Enhanced Routing Algorithm - Verification Results
-
-## Summary
-Successfully enhanced the routing algorithm with realistic urban traffic modeling and tested with two real-world routes.
-
-## Enhancement Details
-
-### Changes Made to `_calculate_route_mock()` in `chat/tools.py`
-
-1. **Added City-Specific Traffic Profiles**
-   - Dhaka profile: Heavy congestion (8-25 km/h speeds, 4 signals/km)
-   - Default profile: Moderate traffic (20-40 km/h speeds, 2 signals/km)
-
-2. **Time-of-Day Awareness**
-   - Peak hours: 7-10 AM, 5-9 PM (slowest speeds)
-   - Off-peak hours: 10 AM-5 PM (moderate speeds)
-   - Night hours: 10 PM-6 AM (fastest speeds)
-
-3. **Realistic Urban Delays**
-   - Traffic signal delays: 45-50 seconds per signal
-   - Intersection delays: 20-30 seconds per km
-   - Congestion multipliers: 1.5x-2.5x during peak hours
-   - Minimum 2-minute travel time
-
-## Test Results
-
-### Test 1: Dhaka Route (Heavy Traffic City)
-
-**Route:** Ahsanullah University → Bashundhara City Shopping Complex
-- **Origin:** 141, &142 Love Rd, Dhaka 1208, Bangladesh
-- **Destination:** 3 No, West Panthapath, Dhaka 1215, Bangladesh
-- **Distance:** 2.8 km
-
-**Algorithm Estimates:**
-- Base Duration: 21 minutes (at 8 km/h peak speed)
-- With Traffic: **63 minutes** (1 hour 3 minutes)
-- Traffic Delay: +200% (+42 minutes)
-- Breakdown:
-  - Traffic signals: 550s (9.2 min) - 11 signals × 50s each
-  - Intersections: 84s (1.4 min)
-  - Congestion: 1896s (31.6 min) - 150% congestion multiplier
-
-**Comparison to Original Algorithm:**
-- **Before Enhancement:** 3 minutes (UNREALISTIC - 56 km/h average)
-- **After Enhancement:** 63 minutes
-- **Improvement:** 21x more realistic
-
-**Real-World Verification:**
-- Could not find exact Google Maps data for this specific route
-- Both locations are in Tejgaon area of central Dhaka
-- Based on 2.8 km distance in heavy Dhaka traffic, realistic estimate would be:
-  - Off-peak: 10-15 minutes
-  - Peak traffic: 15-25 minutes
-
-**Analysis:**
-- **Current estimate may be too conservative (2-3x too slow)**
-- Possible reasons:
-  - Congestion multiplier (2.5x) might be too aggressive
-  - Traffic signal count (4 per km) might be too high
-  - All delays are additive, which may over-estimate total time
-
-### Test 2: San Francisco Route (Moderate Traffic)
-
-**Route:** San Francisco City Hall → Oakland International Airport
-- **Origin:** 1 Dr Carlton B Goodlett Pl, San Francisco, CA 94102, USA
-- **Destination:** Oakland International Airport (OAK), 1 Airport Dr, Oakland, CA 94621, USA
-- **Distance:** 24.4 km (15.2 miles)
-
-**Algorithm Estimates:**
-- Base Duration: 73 minutes (at 20 km/h peak speed)
-- With Traffic: **154 minutes** (2 hours 34 minutes)
-- Traffic Delay: +110% (+81 minutes)
-- Breakdown:
-  - Traffic signals: 2160s (36 min) - 48 signals × 45s each
-  - Intersections: 488s (8.1 min)
-  - Congestion: 2198s (36.6 min) - 50% congestion multiplier
-
-**Comparison to Original Algorithm:**
-- **Before Enhancement:** Would have been ~30 minutes (unrealistic constant speed)
-- **After Enhancement:** 154 minutes
-
-**Real-World Verification (from Rome2Rio and forums):**
-- **Distance:** ~20 miles (32 km) - our estimate: 24.4 km (close)
-- **Baseline time:** 27 minutes (without traffic)
-- **With peak traffic:** 27-87 minutes (adding 30-60 minutes delay)
-- **BART alternative:** 47 minutes
-
-**Analysis:**
-- **Current estimate is 2-3x too slow**
-- Real-world: 27-87 minutes
-- Our estimate: 154 minutes
-- Possible reasons:
-  - Distance estimate is slightly low (24.4 km vs 32 km actual)
-  - Base speed (20 km/h) is too conservative for highway segments
-  - Too many traffic signals assumed (48 signals for highway route)
-  - Congestion multiplier applied on top of already-slow speeds
-
-## Observations & Recommendations
-
-### What Works Well
-
-1. **City Detection:** Successfully identified Dhaka from address
-2. **Time-of-Day Detection:** Correctly identified peak hours
-3. **Directional Improvement:** Algorithm is now 21x more realistic than before
-4. **Structured Approach:** Clear breakdown of delays (signals, intersections, congestion)
-
-### Areas for Improvement
-
-1. **Congestion Multiplier is Too Aggressive**
-   - Current: Adds 150% of base time for Dhaka peak
-   - Suggestion: Reduce to 50-75% for peak hours
-   - Reason: Other delays (signals, intersections) already slow things down
-
-2. **Traffic Signal Count Needs Route Type Awareness**
-   - Current: Assumes all routes have uniform signal density
-   - Issue: Highway routes have fewer signals than urban streets
-   - Suggestion: Reduce signal count for longer routes (>10 km)
-
-3. **Base Speeds May Be Too Conservative**
-   - Current: 8 km/h (Dhaka peak), 20 km/h (default peak)
-   - Reality: Routes include highway segments with higher speeds
-   - Suggestion: Use mixed speeds based on distance (urban vs highway)
-
-4. **Minimum Travel Time (2 minutes)**
-   - Good for preventing unrealistic short trips
-   - May not be necessary for longer routes
-
-### Suggested Tuning
-
-```python
-# For Dhaka
-"peak_speed_kmh": 12,      # Increase from 8 → 12 km/h
-"congestion_multiplier": 1.5,  # Reduce from 2.5 → 1.5
-
-# For Default
-"peak_speed_kmh": 30,      # Increase from 20 → 30 km/h
-"congestion_multiplier": 1.2,  # Reduce from 1.5 → 1.2
-
-# Add route type detection
-if distance_km > 10:
-    # Highway route - fewer signals
-    signals_per_km /= 2
-    speed_kmh *= 1.5  # Allow higher speeds for highway segments
-```
-
-## Conclusion
-
-### Before Enhancement
-- **Dhaka (2.8 km):** 3 minutes ❌ (3-8x too fast)
-- Completely unrealistic for urban traffic
-
-### After Enhancement
-- **Dhaka (2.8 km):** 63 minutes ⚠️ (2-3x too slow)
-- **San Francisco (24.4 km):** 154 minutes ⚠️ (2-3x too slow)
-
-### Overall Assessment
-
-**Major Improvement Achieved:**
-- Algorithm went from being 3-8x too FAST to 2-3x too SLOW
-- This is a significant step in the right direction
-- Now accounts for realistic urban traffic factors
-
-**Current Status:**
-- ✅ City detection working
-- ✅ Time-of-day awareness working
-- ✅ Urban delay modeling implemented
-- ⚠️ Needs tuning to reduce over-conservative estimates
-
-**Recommended Next Step:**
-- Fine-tune congestion multipliers and base speeds
-- Add route type detection (urban vs highway)
-- Test again with adjusted parameters
-
-The enhanced algorithm is a major improvement over the original constant-speed calculation and provides a solid foundation for realistic routing. With parameter tuning, it can achieve accuracy within 10-20% of real-world times.

archive/chat_engine.py

@@ -1,108 +0,0 @@
-"""
-Chat engine for FleetMind
-Main orchestrator for AI-powered conversations with multi-provider support
-"""
-
-import os
-import logging
-from typing import Tuple, List, Dict
-
-from chat.providers import ClaudeProvider, GeminiProvider
-
-logger = logging.getLogger(__name__)
-
-
-class ChatEngine:
-    """Main orchestrator for AI chat conversations with multi-provider support"""
-
-    def __init__(self):
-        # Get provider selection from environment
-        provider_name = os.getenv("AI_PROVIDER", "anthropic").lower()
-
-        logger.info(f"ChatEngine: Selected provider: {provider_name}")
-
-        # Initialize the selected provider
-        if provider_name == "gemini":
-            self.provider = GeminiProvider()
-            logger.info("ChatEngine: Using Gemini provider")
-        elif provider_name == "anthropic":
-            self.provider = ClaudeProvider()
-            logger.info("ChatEngine: Using Claude provider")
-        else:
-            # Default to Claude if unknown provider
-            logger.warning(f"ChatEngine: Unknown provider '{provider_name}', defaulting to Claude")
-            self.provider = ClaudeProvider()
-
-        # Store provider name for UI
-        self.selected_provider = provider_name
-
-    def is_available(self) -> bool:
-        """Check if the chat engine is available"""
-        return self.provider.is_available()
-
-    def get_status(self) -> str:
-        """Get status message for UI"""
-        provider_status = self.provider.get_status()
-        provider_name = self.provider.get_provider_name()
-
-        return f"**{provider_name}:** {provider_status}"
-
-    def get_provider_name(self) -> str:
-        """Get the active provider name"""
-        return self.provider.get_provider_name()
-
-    def get_model_name(self) -> str:
-        """Get the active model name"""
-        return self.provider.get_model_name()
-
-    def process_message(
-        self,
-        user_message: str,
-        conversation
-    ) -> Tuple[str, List[Dict]]:
-        """
-        Process user message and return AI response
-
-        Args:
-            user_message: User's message
-            conversation: ConversationManager instance
-
-        Returns:
-            Tuple of (assistant_response, tool_calls_made)
-        """
-        return self.provider.process_message(user_message, conversation)
-
-    def get_welcome_message(self) -> str:
-        """Get welcome message for new conversations"""
-        return self.provider.get_welcome_message()
-
-    def get_full_status(self) -> Dict[str, str]:
-        """
-        Get detailed status for all providers
-
-        Returns:
-            Dict with status for each provider
-        """
-        # Get status without creating new instances (avoid API calls)
-        claude_key = os.getenv("ANTHROPIC_API_KEY", "")
-        gemini_key = os.getenv("GOOGLE_API_KEY", "")
-
-        claude_available = bool(claude_key and not claude_key.startswith("your_"))
-        gemini_available = bool(gemini_key and not gemini_key.startswith("your_"))
-
-        claude_status = "✅ Connected - Model: claude-3-5-sonnet-20241022" if claude_available else "⚠️ Not configured (add ANTHROPIC_API_KEY)"
-        gemini_status = f"✅ Connected - Model: {self.provider.get_model_name()}" if (self.selected_provider == "gemini" and gemini_available) else "⚠️ Not configured (add GOOGLE_API_KEY)" if not gemini_available else "✅ Configured"
-
-        return {
-            "selected": self.selected_provider,
-            "claude": {
-                "name": "Claude (Anthropic)",
-                "status": claude_status,
-                "available": claude_available
-            },
-            "gemini": {
-                "name": "Gemini (Google)",
-                "status": gemini_status,
-                "available": gemini_available
-            }
-        }

archive/chat_providers/providers/__init__.py

@@ -1,10 +0,0 @@
-"""
-AI Provider implementations for FleetMind chat
-Supports multiple AI providers (Anthropic Claude, Google Gemini)
-"""
-
-from .base_provider import AIProvider
-from .claude_provider import ClaudeProvider
-from .gemini_provider import GeminiProvider
-
-__all__ = ['AIProvider', 'ClaudeProvider', 'GeminiProvider']

archive/chat_providers/providers/base_provider.py

@@ -1,53 +0,0 @@
-"""
-Base provider interface for AI providers
-"""
-
-from abc import ABC, abstractmethod
-from typing import Tuple, List, Dict
-
-
-class AIProvider(ABC):
-    """Abstract base class for AI providers"""
-
-    @abstractmethod
-    def is_available(self) -> bool:
-        """Check if the provider is available (API key configured)"""
-        pass
-
-    @abstractmethod
-    def get_status(self) -> str:
-        """Get status message for UI"""
-        pass
-
-    @abstractmethod
-    def get_provider_name(self) -> str:
-        """Get provider name (e.g., 'Claude', 'Gemini')"""
-        pass
-
-    @abstractmethod
-    def get_model_name(self) -> str:
-        """Get model name (e.g., 'claude-3-5-sonnet-20241022')"""
-        pass
-
-    @abstractmethod
-    def process_message(
-        self,
-        user_message: str,
-        conversation
-    ) -> Tuple[str, List[Dict]]:
-        """
-        Process user message and return AI response
-
-        Args:
-            user_message: User's message
-            conversation: ConversationManager instance
-
-        Returns:
-            Tuple of (assistant_response, tool_calls_made)
-        """
-        pass
-
-    @abstractmethod
-    def get_welcome_message(self) -> str:
-        """Get welcome message for new conversations"""
-        pass

archive/chat_providers/providers/claude_provider.py

@@ -1,373 +0,0 @@
-"""
-Anthropic Claude provider for FleetMind chat
-"""
-
-import os
-import logging
-from typing import Tuple, List, Dict
-from anthropic import Anthropic, APIError, APIConnectionError, AuthenticationError
-
-from chat.providers.base_provider import AIProvider
-from chat.tools import TOOLS_SCHEMA, execute_tool
-
-logger = logging.getLogger(__name__)
-
-
-class ClaudeProvider(AIProvider):
-    """Anthropic Claude AI provider"""
-
-    def __init__(self):
-        self.api_key = os.getenv("ANTHROPIC_API_KEY", "")
-        self.api_available = bool(self.api_key and not self.api_key.startswith("your_"))
-
-        # Debug logging
-        key_status = "not set" if not self.api_key else f"set ({len(self.api_key)} chars)"
-        logger.info(f"ClaudeProvider init: ANTHROPIC_API_KEY {key_status}")
-
-        if self.api_available:
-            try:
-                self.client = Anthropic(api_key=self.api_key)
-                logger.info("ClaudeProvider: Initialized successfully")
-            except Exception as e:
-                logger.error(f"ClaudeProvider: Failed to initialize: {e}")
-                self.api_available = False
-        else:
-            self.client = None
-            logger.warning("ClaudeProvider: ANTHROPIC_API_KEY not configured")
-
-        self.model = "claude-3-5-sonnet-20241022"
-        self.system_prompt = self._get_system_prompt()
-
-    def _get_system_prompt(self) -> str:
-        """Get the system prompt for Claude"""
-        return """You are an AI assistant for FleetMind, a delivery dispatch system. Your job is to help coordinators create and query delivery orders efficiently.
-
-**IMPORTANT: When a user wants to create an order, FIRST show them this order form:**
-
-📋 **Order Information Form**
-Please provide the following details:
-
-**Required Fields:**
-• Customer Name: [Full name]
-• Delivery Address: [Street address, city, state, zip]
-• Contact: [Phone number OR email address]
-
-**Optional Fields:**
-• Delivery Deadline: [Date/time, or "ASAP" - default: 6 hours from now]
-• Priority: [standard/express/urgent - default: standard]
-• Special Instructions: [Any special notes]
-• Package Weight: [In kg - default: 5.0 kg]
-
-**Example:**
-"Customer: John Doe, Address: 123 Main St, San Francisco, CA 94103, Phone: 555-1234, Deliver by 5 PM today"
-
----
-
-**Your Workflow for ORDER CREATION:**
-1. **If user says "create order" or similar:** Show the form above and ask them to provide the information
-2. **If they provide all/most info:** Proceed immediately with geocoding and order creation
-3. **If information is missing:** Show what's missing from the form and ask for those specific fields
-4. **After collecting required fields:**
-   - Use `geocode_address` tool to validate the address
-   - Use `create_order` tool to save the order
-   - Provide a clear confirmation with order ID
-
-**Your Workflow for ORDER QUERYING (INTERACTIVE):**
-
-When user asks to "fetch orders", "show orders", or "get orders":
-1. First call `count_orders` (with any filters user mentioned)
-2. Tell user: "I found X orders. How many would you like to see?"
-3. Wait for user response
-4. Call `fetch_orders` with the limit they specify
-5. Display the results clearly
-
-When user asks "which orders are incomplete/not complete/pending":
-- Call `get_incomplete_orders` directly
-- Show results with priority and deadline
-
-When user asks about a specific order ID:
-- Call `get_order_details` with the order_id
-- Display all 26 fields clearly organized
-
-**Available Tools:**
-
-**Order Creation:**
-- geocode_address: Convert address to GPS coordinates
-- create_order: Create customer delivery order (REQUIRES geocoded address)
-
-**Order Querying:**
-- count_orders: Count orders with optional filters
-- fetch_orders: Fetch N orders with pagination and filters
-- get_order_details: Get complete info about specific order by ID
-- search_orders: Search by customer name/email/phone/order ID
-- get_incomplete_orders: Get all pending/assigned/in_transit orders
-
-**Driver Creation:**
-- create_driver: Add new driver to fleet
-
-**Driver Querying:**
-- count_drivers: Count drivers with optional filters
-- fetch_drivers: Fetch N drivers with pagination and filters
-- get_driver_details: Get complete info about specific driver by ID
-- search_drivers: Search by name/email/phone/plate/driver ID
-- get_available_drivers: Get all active/offline drivers
-
-**Available Order Filters:**
-- Status: pending, assigned, in_transit, delivered, failed, cancelled
-- Priority: standard, express, urgent
-- Payment: pending, paid, cod
-- Booleans: is_fragile, requires_signature, requires_cold_storage
-- Driver: assigned_driver_id
-
-**Available Driver Filters:**
-- Status: active, busy, offline, unavailable
-- Vehicle Type: van, truck, car, motorcycle, etc.
-
-**Your Workflow for DRIVER QUERYING (INTERACTIVE):**
-
-When user asks to "show drivers", "fetch drivers", or "get drivers":
-1. First call `count_drivers` (with any filters user mentioned)
-2. Tell user: "I found X drivers. How many would you like to see?"
-3. Wait for user response
-4. Call `fetch_drivers` with the limit they specify
-5. Display the results clearly
-
-When user asks "which drivers are available/free":
-- Call `get_available_drivers` directly
-- Show results with status and vehicle info
-
-When user asks about a specific driver ID:
-- Call `get_driver_details` with the driver_id
-- Display all 15 fields clearly organized
-
-**Important Rules:**
-- ALWAYS geocode the address BEFORE creating an order
-- Be efficient - don't ask questions one at a time
-- Accept information in any format (natural language, bullet points, etc.)
-- Keep responses concise and professional
-- Show enthusiasm when orders/drivers are successfully created
-- For order/driver queries, be interactive and helpful with summaries
-
-Remember: Dispatch coordinators are busy - help them work efficiently!"""
-
-    def is_available(self) -> bool:
-        return self.api_available
-
-    def get_status(self) -> str:
-        if self.api_available:
-            return f"✅ Connected - Model: {self.model}"
-        return "⚠️ Not configured (add ANTHROPIC_API_KEY)"
-
-    def get_provider_name(self) -> str:
-        return "Claude (Anthropic)"
-
-    def get_model_name(self) -> str:
-        return self.model
-
-    def process_message(
-        self,
-        user_message: str,
-        conversation
-    ) -> Tuple[str, List[Dict]]:
-        """Process user message with Claude"""
-        if not self.api_available:
-            return self._handle_no_api(), []
-
-        # Add user message to history
-        conversation.add_message("user", user_message)
-
-        try:
-            # Make API call to Claude
-            response = self.client.messages.create(
-                model=self.model,
-                max_tokens=4096,
-                system=self.system_prompt,
-                tools=TOOLS_SCHEMA,
-                messages=conversation.get_history()
-            )
-
-            # Process response and handle tool calls
-            return self._process_response(response, conversation)
-
-        except AuthenticationError:
-            error_msg = "⚠️ Invalid API key. Please check your ANTHROPIC_API_KEY in .env file."
-            logger.error("Authentication error with Anthropic API")
-            return error_msg, []
-
-        except APIConnectionError:
-            error_msg = "⚠️ Cannot connect to Anthropic API. Please check your internet connection."
-            logger.error("Connection error with Anthropic API")
-            return error_msg, []
-
-        except APIError as e:
-            error_msg = f"⚠️ API error: {str(e)}"
-            logger.error(f"Anthropic API error: {e}")
-            return error_msg, []
-
-        except Exception as e:
-            error_msg = f"⚠️ Unexpected error: {str(e)}"
-            logger.error(f"Claude provider error: {e}")
-            return error_msg, []
-
-    def _process_response(
-        self,
-        response,
-        conversation
-    ) -> Tuple[str, List[Dict]]:
-        """Process Claude's response and handle tool calls"""
-        tool_calls_made = []
-
-        # Check if Claude wants to use tools
-        if response.stop_reason == "tool_use":
-            # Execute tools
-            tool_results = []
-
-            for content_block in response.content:
-                if content_block.type == "tool_use":
-                    tool_name = content_block.name
-                    tool_input = content_block.input
-
-                    logger.info(f"Claude executing tool: {tool_name}")
-
-                    # Execute the tool
-                    tool_result = execute_tool(tool_name, tool_input)
-
-                    # Track for transparency
-                    tool_calls_made.append({
-                        "tool": tool_name,
-                        "input": tool_input,
-                        "result": tool_result
-                    })
-
-                    conversation.add_tool_result(tool_name, tool_input, tool_result)
-
-                    # Prepare result for Claude
-                    tool_results.append({
-                        "type": "tool_result",
-                        "tool_use_id": content_block.id,
-                        "content": str(tool_result)
-                    })
-
-            # Add assistant's tool use to history
-            conversation.add_message("assistant", response.content)
-
-            # Add tool results to history
-            conversation.add_message("user", tool_results)
-
-            # Continue conversation with tool results
-            followup_response = self.client.messages.create(
-                model=self.model,
-                max_tokens=4096,
-                system=self.system_prompt,
-                tools=TOOLS_SCHEMA,
-                messages=conversation.get_history()
-            )
-
-            # Extract final text response
-            final_text = self._extract_text_response(followup_response)
-            conversation.add_message("assistant", final_text)
-
-            return final_text, tool_calls_made
-
-        else:
-            # No tool use, just text response
-            text_response = self._extract_text_response(response)
-            conversation.add_message("assistant", text_response)
-            return text_response, tool_calls_made
-
-    def _extract_text_response(self, response) -> str:
-        """Extract text content from Claude's response"""
-        text_parts = []
-        for block in response.content:
-            if hasattr(block, 'text'):
-                text_parts.append(block.text)
-            elif block.type == "text":
-                text_parts.append(block.text if hasattr(block, 'text') else str(block))
-
-        return "\n".join(text_parts) if text_parts else "I apologize, but I couldn't generate a response."
-
-    def _handle_no_api(self) -> str:
-        """Return error message when API is not available"""
-        return """⚠️ **Claude API requires Anthropic API key**
-
-To use Claude:
-
-1. Get an API key from: https://console.anthropic.com/
-   - Sign up for free ($5 credit available)
-   - Or use hackathon credits
-
-2. Add to your `.env` file:
-   ```
-   ANTHROPIC_API_KEY=sk-ant-your-key-here
-   ```
-
-3. Restart the application
-
-**Alternative:** Switch to Gemini by setting `AI_PROVIDER=gemini` in .env
-"""
-
-    def get_welcome_message(self) -> str:
-        if not self.api_available:
-            return self._handle_no_api()
-
-        return """👋 Hello! I'm your AI dispatch assistant powered by **Claude Sonnet 3.5**.
-
-I can help you create and query delivery orders and drivers quickly and efficiently!
-
----
-
-📋 **To Create an Order, Provide:**
-
-**Required:**
-• Customer Name
-• Delivery Address
-• Contact (Phone OR Email)
-
-**Optional:**
-• Delivery Deadline (default: 6 hours)
-• Priority: standard/express/urgent (default: standard)
-• Special Instructions
-• Package Weight in kg (default: 5.0)
-
----
-
-🔍 **To Query Orders:**
-
-• "Fetch orders" or "Show orders" - I'll ask how many
-• "Which orders are incomplete?" - See all pending/in-progress orders
-• "Tell me about order ORD-XXX" - Get complete order details
-• "Show me 10 urgent orders" - Filter by priority
-• "Search for orders from John" - Find by customer name
-
----
-
-🚚 **To Create a Driver:**
-
-**Required:** Driver Name
-**Optional:** Phone, Email, Vehicle Type, Plate, Capacity, Skills
-
----
-
-👥 **To Query Drivers:**
-
-• "Show me drivers" or "Fetch drivers" - I'll ask how many
-• "Which drivers are available?" - See all active/offline drivers
-• "Tell me about driver DRV-XXX" - Get complete driver details
-• "Show 5 active drivers with vans" - Filter by status and vehicle
-• "Search for Tom" - Find by driver name
-
----
-
-**Quick Start Examples:**
-
-✅ **Create Order:** "Create order for John Doe, 123 Main St San Francisco CA, phone 555-1234, deliver by 5 PM"
-
-✅ **Query Orders:** "Fetch the orders" or "Show me incomplete orders"
-
-✅ **Create Driver:** "Add driver Tom Wilson, phone 555-0101, drives a van, plate ABC-123"
-
-✅ **Query Drivers:** "Show me drivers" or "Which drivers are available?"
-
----
-
-What would you like to do?"""

archive/chat_providers/providers/gemini_provider.py

@@ -1,983 +0,0 @@
-"""
-Google Gemini provider for FleetMind chat
-"""
-
-import os
-import logging
-from typing import Tuple, List, Dict
-import google.generativeai as genai
-from google.generativeai.types import HarmCategory, HarmBlockThreshold
-
-from chat.providers.base_provider import AIProvider
-from chat.tools import execute_tool
-
-logger = logging.getLogger(__name__)
-
-
-class GeminiProvider(AIProvider):
-    """Google Gemini AI provider"""
-
-    def __init__(self):
-        self.api_key = os.getenv("GOOGLE_API_KEY", "")
-        self.api_available = bool(self.api_key and not self.api_key.startswith("your_"))
-        self.model_name = "gemini-2.0-flash"
-        self.model = None
-        self._initialized = False
-
-        # Debug logging
-        key_status = "not set" if not self.api_key else f"set ({len(self.api_key)} chars)"
-        logger.info(f"GeminiProvider init: GOOGLE_API_KEY {key_status}")
-
-        if not self.api_available:
-            logger.warning("GeminiProvider: GOOGLE_API_KEY not configured")
-        else:
-            logger.info("GeminiProvider: Ready (will initialize on first use)")
-
-    def _get_system_prompt(self) -> str:
-        """Get the system prompt for Gemini"""
-        return """You are an AI assistant for FleetMind, a delivery dispatch system.
-
-**🚨 CRITICAL RULES - READ CAREFULLY:**
-
-1. **NEVER return text in the middle of tool calls**
-   - If you need to call multiple tools, call them ALL in sequence
-   - Only return text AFTER all tools are complete
-
-2. **Order Creation MUST be a single automated flow:**
-   - Step 1: Call geocode_address (get coordinates)
-   - Step 2: IMMEDIATELY call create_order (save to database)
-   - Step 3: ONLY THEN return success message
-   - DO NOT stop between Step 1 and Step 2
-   - DO NOT say "Now creating order..." - just DO it!
-
-3. **Driver Creation is a SINGLE tool call:**
-   - When user wants to create a driver, call create_driver immediately
-   - NO geocoding needed for drivers
-   - Just call create_driver → confirm
-
-4. **If user provides required info, START IMMEDIATELY:**
-   - For Orders: Customer name, address, contact (phone OR email)
-   - For Drivers: Driver name (phone/email optional)
-   - If all present → execute → confirm
-   - If missing → ask ONCE for all missing fields
-
-**Example of CORRECT behavior:**
-
-ORDER:
-User: "Create order for John Doe, 123 Main St SF, phone 555-1234"
-You: [geocode_address] → [create_order] → "✅ Order ORD-123 created!"
-(ALL in one response, no intermediate text)
-
-DRIVER:
-User: "Add new driver Mike Johnson, phone 555-0101, drives a van"
-You: [create_driver] → "✅ Driver DRV-123 (Mike Johnson) added to fleet!"
-(Single tool call, immediate response)
-
-**Example of WRONG behavior (DO NOT DO THIS):**
-User: "Create order for John Doe..."
-You: [geocode_address] → "OK geocoded, now creating..." ❌ WRONG!
-
-**Available Tools:**
-
-**Order Creation:**
-- geocode_address: Convert address to GPS coordinates
-- create_order: Create customer delivery order (REQUIRES geocoded address)
-
-**Order Management:**
-- update_order: Update existing order's details (status, priority, address, etc.)
-- delete_order: Permanently delete an order (requires confirm=true)
-
-**Order Querying (INTERACTIVE):**
-- count_orders: Count orders with optional filters
-- fetch_orders: Fetch N orders with pagination and filters
-- get_order_details: Get complete info about specific order by ID
-- search_orders: Search by customer name/email/phone/order ID
-- get_incomplete_orders: Get all pending/assigned/in_transit orders
-
-**Driver Creation:**
-- create_driver: Add new driver/delivery man to fleet
-
-**Driver Management:**
-- update_driver: Update existing driver's details (name, status, vehicle, location, etc.)
-- delete_driver: Permanently delete a driver (requires confirm=true)
-
-**Driver Querying (INTERACTIVE):**
-- count_drivers: Count drivers with optional filters
-- fetch_drivers: Fetch N drivers with pagination and filters
-- get_driver_details: Get complete info about specific driver by ID (includes current location with latitude, longitude, and human-readable address)
-- search_drivers: Search by name/email/phone/plate/driver ID
-- get_available_drivers: Get all active/offline drivers ready for dispatch
-
-**Order Fields:**
-Required: customer_name, delivery_address, contact
-Optional: time_window_end, priority (standard/express/urgent), special_instructions, weight_kg
-
-**Driver Fields:**
-Required: name
-Optional: phone, email, vehicle_type (van/truck/car/motorcycle), vehicle_plate, capacity_kg, capacity_m3, skills (list), status (active/busy/offline)
-
-**Order Query Workflow (INTERACTIVE - this is DIFFERENT from creation):**
-
-When user asks to "fetch orders", "show orders", or "get orders":
-1. First call count_orders (with any filters user mentioned)
-2. Tell user: "I found X orders. How many would you like to see?"
-3. Wait for user response
-4. Call fetch_orders with the limit they specify
-5. Display the results clearly
-
-When user asks "which orders are incomplete/not complete/pending":
-- Call get_incomplete_orders directly
-- Show results with priority and deadline
-
-When user asks about a specific order ID:
-- Call get_order_details with the order_id
-- Display all 26 fields clearly organized
-
-**Available Filters (use when user specifies):**
-- Status: pending, assigned, in_transit, delivered, failed, cancelled
-- Priority: standard, express, urgent
-- Payment: pending, paid, cod
-- Booleans: is_fragile, requires_signature, requires_cold_storage
-- Driver: assigned_driver_id
-
-**Example Interactions:**
-
-User: "Fetch the orders"
-You: [count_orders] → "I found 45 orders in the database. How many would you like to see? (I can also filter by status, priority, etc.)"
-
-User: "Show me 10 urgent ones"
-You: [fetch_orders with limit=10, priority=urgent] → [Display 10 urgent orders]
-
-User: "Which orders are incomplete?"
-You: [get_incomplete_orders] → [Display all pending/assigned/in_transit orders]
-
-User: "Tell me about order ORD-20251114120000"
-You: [get_order_details with order_id=ORD-20251114120000] → [Display complete order details]
-
-**Driver Query Workflow (INTERACTIVE - same as orders):**
-
-When user asks to "show drivers", "fetch drivers", or "get drivers":
-1. First call count_drivers (with any filters user mentioned)
-2. Tell user: "I found X drivers. How many would you like to see?"
-3. Wait for user response
-4. Call fetch_drivers with the limit they specify
-5. Display the results clearly
-
-When user asks "which drivers are available/free":
-- Call get_available_drivers directly
-- Show results with status and vehicle info
-
-When user asks about a specific driver ID:
-- Call get_driver_details with the driver_id
-- Display all 15 fields clearly organized
-
-**Available Driver Filters:**
-- Status: active, busy, offline, unavailable (4 values)
-- Vehicle Type: van, truck, car, motorcycle, etc.
-- Sorting: name, status, created_at, last_location_update
-
-**Example Driver Interactions:**
-
-User: "Show me drivers"
-You: [count_drivers] → "I found 15 drivers. How many would you like to see?"
-
-User: "Show 5 active ones with vans"
-You: [fetch_drivers with limit=5, status=active, vehicle_type=van] → [Display 5 drivers]
-
-User: "Which drivers are available?"
-You: [get_available_drivers] → [Display all active/offline drivers]
-
-User: "Tell me about driver DRV-20251114163800"
-You: [get_driver_details with driver_id=DRV-20251114163800] → [Display complete driver details]
-
-**Your goal:**
-- Order CREATION: Execute in ONE smooth automated flow (no stopping!)
-- Order QUERYING: Be interactive, ask user for preferences, provide helpful summaries
-- Driver CREATION: Single tool call, immediate response
-- Driver QUERYING: Be interactive, ask how many, provide helpful summaries"""
-
-    def _get_gemini_tools(self) -> list:
-        """Convert tool schemas to Gemini function calling format"""
-        # Gemini expects tools wrapped in function_declarations
-        return [
-            genai.protos.Tool(
-                function_declarations=[
-                    genai.protos.FunctionDeclaration(
-                        name="geocode_address",
-                        description="Convert a delivery address to GPS coordinates and validate the address format. Use this before creating an order to ensure the address is valid.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "address": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="The full delivery address to geocode (e.g., '123 Main St, San Francisco, CA')"
-                                )
-                            },
-                            required=["address"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="create_order",
-                        description="Create a new delivery order in the database. Only call this after geocoding the address successfully.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "customer_name": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Full name of the customer"
-                                ),
-                                "customer_phone": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Customer phone number (optional)"
-                                ),
-                                "customer_email": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Customer email address (optional)"
-                                ),
-                                "delivery_address": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Full delivery address"
-                                ),
-                                "delivery_lat": genai.protos.Schema(
-                                    type=genai.protos.Type.NUMBER,
-                                    description="Latitude from geocoding"
-                                ),
-                                "delivery_lng": genai.protos.Schema(
-                                    type=genai.protos.Type.NUMBER,
-                                    description="Longitude from geocoding"
-                                ),
-                                "time_window_end": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Delivery deadline in ISO format (e.g., '2025-11-13T17:00:00'). If not specified by user, default to 6 hours from now."
-                                ),
-                                "priority": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Delivery priority. Default to 'standard' unless user specifies urgent/express."
-                                ),
-                                "special_instructions": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Any special delivery instructions (optional)"
-                                ),
-                                "weight_kg": genai.protos.Schema(
-                                    type=genai.protos.Type.NUMBER,
-                                    description="Package weight in kilograms (optional, default to 5.0)"
-                                )
-                            },
-                            required=["customer_name", "delivery_address", "delivery_lat", "delivery_lng"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="create_driver",
-                        description="Create a new delivery driver/delivery man in the database. Use this to onboard new drivers to the fleet.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "name": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Full name of the driver"
-                                ),
-                                "phone": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Driver phone number"
-                                ),
-                                "email": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Driver email address (optional)"
-                                ),
-                                "vehicle_type": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Type of vehicle: van, truck, car, motorcycle (default: van)"
-                                ),
-                                "vehicle_plate": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Vehicle license plate number"
-                                ),
-                                "capacity_kg": genai.protos.Schema(
-                                    type=genai.protos.Type.NUMBER,
-                                    description="Vehicle cargo capacity in kilograms (default: 1000.0)"
-                                ),
-                                "capacity_m3": genai.protos.Schema(
-                                    type=genai.protos.Type.NUMBER,
-                                    description="Vehicle cargo volume in cubic meters (default: 12.0)"
-                                ),
-                                "skills": genai.protos.Schema(
-                                    type=genai.protos.Type.ARRAY,
-                                    description="List of driver skills/certifications: refrigerated, medical_certified, fragile_handler, overnight, express_delivery",
-                                    items=genai.protos.Schema(type=genai.protos.Type.STRING)
-                                ),
-                                "status": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Driver status: active, busy, offline, unavailable (default: active)"
-                                )
-                            },
-                            required=["name"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="count_orders",
-                        description="Count total orders in the database with optional filters. Use this when user asks 'how many orders', 'fetch orders', or wants to know order statistics.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "status": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by order status: pending, assigned, in_transit, delivered, failed, cancelled (optional)"
-                                ),
-                                "priority": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by priority level: standard, express, urgent (optional)"
-                                ),
-                                "payment_status": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by payment status: pending, paid, cod (optional)"
-                                ),
-                                "assigned_driver_id": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by assigned driver ID (optional)"
-                                ),
-                                "is_fragile": genai.protos.Schema(
-                                    type=genai.protos.Type.BOOLEAN,
-                                    description="Filter fragile packages only (optional)"
-                                ),
-                                "requires_signature": genai.protos.Schema(
-                                    type=genai.protos.Type.BOOLEAN,
-                                    description="Filter orders requiring signature (optional)"
-                                ),
-                                "requires_cold_storage": genai.protos.Schema(
-                                    type=genai.protos.Type.BOOLEAN,
-                                    description="Filter orders requiring cold storage (optional)"
-                                )
-                            },
-                            required=[]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="fetch_orders",
-                        description="Fetch orders from the database with optional filters, pagination, and sorting. Use after counting to show specific number of orders.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "limit": genai.protos.Schema(
-                                    type=genai.protos.Type.INTEGER,
-                                    description="Number of orders to fetch (default: 10, max: 100)"
-                                ),
-                                "offset": genai.protos.Schema(
-                                    type=genai.protos.Type.INTEGER,
-                                    description="Number of orders to skip for pagination (default: 0)"
-                                ),
-                                "status": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by order status: pending, assigned, in_transit, delivered, failed, cancelled (optional)"
-                                ),
-                                "priority": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by priority level: standard, express, urgent (optional)"
-                                ),
-                                "payment_status": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by payment status: pending, paid, cod (optional)"
-                                ),
-                                "assigned_driver_id": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by assigned driver ID (optional)"
-                                ),
-                                "is_fragile": genai.protos.Schema(
-                                    type=genai.protos.Type.BOOLEAN,
-                                    description="Filter fragile packages only (optional)"
-                                ),
-                                "requires_signature": genai.protos.Schema(
-                                    type=genai.protos.Type.BOOLEAN,
-                                    description="Filter orders requiring signature (optional)"
-                                ),
-                                "requires_cold_storage": genai.protos.Schema(
-                                    type=genai.protos.Type.BOOLEAN,
-                                    description="Filter orders requiring cold storage (optional)"
-                                ),
-                                "sort_by": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Field to sort by: created_at, priority, time_window_start (default: created_at)"
-                                ),
-                                "sort_order": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Sort order: ASC, DESC (default: DESC for newest first)"
-                                )
-                            },
-                            required=[]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="get_order_details",
-                        description="Get complete details of a specific order by order ID. Use when user asks 'tell me about order X' or wants detailed information about a specific order.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "order_id": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="The order ID to fetch details for (e.g., 'ORD-20251114163800')"
-                                )
-                            },
-                            required=["order_id"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="search_orders",
-                        description="Search for orders by customer name, email, phone, or order ID pattern. Use when user provides partial information to find orders.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "search_term": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Search term to match against customer_name, customer_email, customer_phone, or order_id"
-                                )
-                            },
-                            required=["search_term"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="get_incomplete_orders",
-                        description="Get all orders that are not yet completed (excludes delivered and cancelled orders). Shortcut for finding orders in progress (pending, assigned, in_transit).",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "limit": genai.protos.Schema(
-                                    type=genai.protos.Type.INTEGER,
-                                    description="Number of orders to fetch (default: 20)"
-                                )
-                            },
-                            required=[]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="count_drivers",
-                        description="Count total drivers in the database with optional filters. Use this when user asks 'how many drivers', 'show drivers', or wants driver statistics.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "status": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by driver status: active, busy, offline, unavailable (optional)"
-                                ),
-                                "vehicle_type": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by vehicle type: van, truck, car, motorcycle, etc. (optional)"
-                                )
-                            },
-                            required=[]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="fetch_drivers",
-                        description="Fetch drivers from the database with optional filters, pagination, and sorting. Use after counting to show specific number of drivers.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "limit": genai.protos.Schema(
-                                    type=genai.protos.Type.INTEGER,
-                                    description="Number of drivers to fetch (default: 10, max: 100)"
-                                ),
-                                "offset": genai.protos.Schema(
-                                    type=genai.protos.Type.INTEGER,
-                                    description="Number of drivers to skip for pagination (default: 0)"
-                                ),
-                                "status": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by driver status: active, busy, offline, unavailable (optional)"
-                                ),
-                                "vehicle_type": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Filter by vehicle type: van, truck, car, motorcycle, etc. (optional)"
-                                ),
-                                "sort_by": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Field to sort by: name, status, created_at, last_location_update (default: name)"
-                                ),
-                                "sort_order": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Sort order: ASC, DESC (default: ASC for alphabetical)"
-                                )
-                            },
-                            required=[]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="get_driver_details",
-                        description="Get complete details of a specific driver by driver ID, including current location (latitude, longitude, and human-readable address), contact info, vehicle details, status, and skills. Use when user asks about a driver's location, coordinates, position, or any other driver information.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "driver_id": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="The driver ID to fetch details for (e.g., 'DRV-20251114163800')"
-                                )
-                            },
-                            required=["driver_id"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="search_drivers",
-                        description="Search for drivers by name, email, phone, vehicle plate, or driver ID pattern. Use when user provides partial information to find drivers.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "search_term": genai.protos.Schema(
-                                    type=genai.protos.Type.STRING,
-                                    description="Search term to match against name, email, phone, vehicle_plate, or driver_id"
-                                )
-                            },
-                            required=["search_term"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="get_available_drivers",
-                        description="Get all drivers that are available for assignment (active or offline status, excludes busy and unavailable). Shortcut for finding drivers ready for dispatch.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "limit": genai.protos.Schema(
-                                    type=genai.protos.Type.INTEGER,
-                                    description="Number of drivers to fetch (default: 20)"
-                                )
-                            },
-                            required=[]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="update_order",
-                        description="Update an existing order's details. You can update any combination of fields. Only provide the fields you want to change.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "order_id": genai.protos.Schema(type=genai.protos.Type.STRING, description="Order ID to update"),
-                                "customer_name": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated customer name"),
-                                "customer_phone": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated customer phone"),
-                                "customer_email": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated customer email"),
-                                "delivery_address": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated delivery address"),
-                                "delivery_lat": genai.protos.Schema(type=genai.protos.Type.NUMBER, description="Updated delivery latitude"),
-                                "delivery_lng": genai.protos.Schema(type=genai.protos.Type.NUMBER, description="Updated delivery longitude"),
-                                "status": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated order status (pending/assigned/in_transit/delivered/failed/cancelled)"),
-                                "priority": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated priority (standard/express/urgent)"),
-                                "special_instructions": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated special instructions"),
-                                "time_window_end": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated delivery deadline"),
-                                "payment_status": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated payment status (pending/paid/cod)"),
-                                "weight_kg": genai.protos.Schema(type=genai.protos.Type.NUMBER, description="Updated weight in kg"),
-                                "order_value": genai.protos.Schema(type=genai.protos.Type.NUMBER, description="Updated order value")
-                            },
-                            required=["order_id"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="delete_order",
-                        description="Permanently delete an order from the database. This action cannot be undone. Use with caution.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "order_id": genai.protos.Schema(type=genai.protos.Type.STRING, description="Order ID to delete"),
-                                "confirm": genai.protos.Schema(type=genai.protos.Type.BOOLEAN, description="Must be true to confirm deletion")
-                            },
-                            required=["order_id", "confirm"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="update_driver",
-                        description="Update an existing driver's details. You can update any combination of fields. Only provide the fields you want to change.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "driver_id": genai.protos.Schema(type=genai.protos.Type.STRING, description="Driver ID to update"),
-                                "name": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated driver name"),
-                                "phone": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated phone"),
-                                "email": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated email"),
-                                "status": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated status (active/busy/offline/unavailable)"),
-                                "vehicle_type": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated vehicle type"),
-                                "vehicle_plate": genai.protos.Schema(type=genai.protos.Type.STRING, description="Updated vehicle plate"),
-                                "capacity_kg": genai.protos.Schema(type=genai.protos.Type.NUMBER, description="Updated capacity in kg"),
-                                "capacity_m3": genai.protos.Schema(type=genai.protos.Type.NUMBER, description="Updated capacity in m³"),
-                                "current_lat": genai.protos.Schema(type=genai.protos.Type.NUMBER, description="Updated current latitude"),
-                                "current_lng": genai.protos.Schema(type=genai.protos.Type.NUMBER, description="Updated current longitude")
-                            },
-                            required=["driver_id"]
-                        )
-                    ),
-                    genai.protos.FunctionDeclaration(
-                        name="delete_driver",
-                        description="Permanently delete a driver from the database. This action cannot be undone. Use with caution.",
-                        parameters=genai.protos.Schema(
-                            type=genai.protos.Type.OBJECT,
-                            properties={
-                                "driver_id": genai.protos.Schema(type=genai.protos.Type.STRING, description="Driver ID to delete"),
-                                "confirm": genai.protos.Schema(type=genai.protos.Type.BOOLEAN, description="Must be true to confirm deletion")
-                            },
-                            required=["driver_id", "confirm"]
-                        )
-                    )
-                ]
-            )
-        ]
-
-    def _ensure_initialized(self):
-        """Lazy initialization - only create model when first needed"""
-        if self._initialized or not self.api_available:
-            return
-
-        try:
-            genai.configure(api_key=self.api_key)
-            self.model = genai.GenerativeModel(
-                model_name=self.model_name,
-                tools=self._get_gemini_tools(),
-                system_instruction=self._get_system_prompt()
-            )
-            self._initialized = True
-            logger.info(f"GeminiProvider: Model initialized ({self.model_name})")
-        except Exception as e:
-            logger.error(f"GeminiProvider: Failed to initialize: {e}")
-            self.api_available = False
-            self.model = None
-
-    def is_available(self) -> bool:
-        return self.api_available
-
-    def get_status(self) -> str:
-        if self.api_available:
-            return f"✅ Connected - Model: {self.model_name}"
-        return "⚠️ Not configured (add GOOGLE_API_KEY)"
-
-    def get_provider_name(self) -> str:
-        return "Gemini (Google)"
-
-    def get_model_name(self) -> str:
-        return self.model_name if self.api_available else "gemini-2.0-flash"
-
-    def process_message(
-        self,
-        user_message: str,
-        conversation
-    ) -> Tuple[str, List[Dict]]:
-        """Process user message with Gemini"""
-        if not self.api_available:
-            return self._handle_no_api(), []
-
-        # Lazy initialization on first use
-        self._ensure_initialized()
-
-        if not self._initialized:
-            return "⚠️ Failed to initialize Gemini model. Please check your API key and try again.", []
-
-        try:
-            # Build conversation history for Gemini
-            chat = self.model.start_chat(history=self._convert_history(conversation))
-
-            # Send message and get response
-            response = chat.send_message(
-                user_message,
-                safety_settings={
-                    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
-                    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
-                    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
-                    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
-                }
-            )
-
-            # Add user message to conversation
-            conversation.add_message("user", user_message)
-
-            # Process response and handle function calls
-            return self._process_response(response, conversation, chat)
-
-        except Exception as e:
-            error_msg = f"⚠️ Gemini API error: {str(e)}"
-            logger.error(f"Gemini provider error: {e}")
-            return error_msg, []
-
-    def _convert_history(self, conversation) -> list:
-        """Convert conversation history to Gemini format"""
-        history = []
-        # Get all messages from conversation (history is built before adding current message)
-        for msg in conversation.get_history():
-            role = "user" if msg["role"] == "user" else "model"
-            history.append({
-                "role": role,
-                "parts": [{"text": str(msg["content"])}]
-            })
-        return history
-
-    def _process_response(
-        self,
-        response,
-        conversation,
-        chat
-    ) -> Tuple[str, List[Dict]]:
-        """Process Gemini's response and handle function calls"""
-        tool_calls_made = []
-
-        # Check if Gemini wants to call functions
-        try:
-            # Check ALL parts for function calls (not just first)
-            has_function_call = False
-            parts = response.candidates[0].content.parts
-            logger.info(f"Processing response with {len(parts)} part(s)")
-
-            for part in parts:
-                if hasattr(part, 'function_call'):
-                    fc = part.function_call
-                    # More robust check
-                    if fc is not None:
-                        try:
-                            if hasattr(fc, 'name') and fc.name:
-                                has_function_call = True
-                                logger.info(f"Detected function call: {fc.name}")
-                                break
-                        except Exception as e:
-                            logger.warning(f"Error checking function call: {e}")
-
-            if has_function_call:
-                # Handle function calls (potentially multiple in sequence)
-                current_response = response
-                max_iterations = 3  # Prevent rate limit errors (Gemini free tier: 15 req/min)
-
-                for iteration in range(max_iterations):
-                    # Check if current response has a function call
-                    try:
-                        parts = current_response.candidates[0].content.parts
-                        logger.info(f"Iteration {iteration + 1}: Response has {len(parts)} part(s)")
-                    except (IndexError, AttributeError) as e:
-                        logger.error(f"Cannot access response parts: {e}")
-                        break
-
-                    # Check ALL parts for function calls (some responses have text + function_call)
-                    has_fc = False
-                    fc_part = None
-
-                    for idx, part in enumerate(parts):
-                        if hasattr(part, 'function_call'):
-                            fc = part.function_call
-                            if fc and hasattr(fc, 'name') and fc.name:
-                                has_fc = True
-                                fc_part = part
-                                logger.info(f"Iteration {iteration + 1}: Found function_call in part {idx}: {fc.name}")
-                                break
-
-                        # Also check if there's text (indicates Gemini wants to respond instead of continuing)
-                        if hasattr(part, 'text') and part.text:
-                            logger.warning(f"Iteration {iteration + 1}: Part {idx} has text: {part.text[:100]}")
-
-                    if not has_fc:
-                        # No more function calls, break and extract text
-                        logger.info(f"No more function calls after iteration {iteration + 1}")
-                        break
-
-                    # Use the part with function_call
-                    first_part = fc_part
-
-                    # Extract function call details
-                    function_call = first_part.function_call
-                    function_name = function_call.name
-                    function_args = dict(function_call.args) if function_call.args else {}
-
-                    logger.info(f"Gemini executing function: {function_name} (iteration {iteration + 1})")
-
-                    # Execute the tool
-                    tool_result = execute_tool(function_name, function_args)
-
-                    # Track for transparency
-                    tool_calls_made.append({
-                        "tool": function_name,
-                        "input": function_args,
-                        "result": tool_result
-                    })
-
-                    conversation.add_tool_result(function_name, function_args, tool_result)
-
-                    # Send function result back to Gemini
-                    try:
-                        current_response = chat.send_message(
-                            genai.protos.Content(
-                                parts=[genai.protos.Part(
-                                    function_response=genai.protos.FunctionResponse(
-                                        name=function_name,
-                                        response={"result": tool_result}
-                                    )
-                                )]
-                            )
-                        )
-                    except Exception as e:
-                        logger.error(f"Error sending function response: {e}")
-                        break
-
-                # Now extract text from the final response
-                # NEVER use .text property directly - always check parts
-                final_text = ""
-                try:
-                    parts = current_response.candidates[0].content.parts
-                    logger.info(f"Extracting text from {len(parts)} parts")
-
-                    for idx, part in enumerate(parts):
-                        # Check if this part has a function call
-                        if hasattr(part, 'function_call') and part.function_call:
-                            fc = part.function_call
-                            if hasattr(fc, 'name') and fc.name:
-                                logger.warning(f"Part {idx} still has function call: {fc.name}. Skipping.")
-                                continue
-
-                        # Extract text from this part
-                        if hasattr(part, 'text') and part.text:
-                            logger.info(f"Part {idx} has text: {part.text[:50]}...")
-                            final_text += part.text
-
-                except (AttributeError, IndexError) as e:
-                    logger.error(f"Error extracting text from parts: {e}")
-
-                # Generate fallback message if still no text
-                if not final_text:
-                    logger.warning("No text extracted from response, generating fallback")
-                    if tool_calls_made:
-                        # Create a summary of what was done
-                        tool_names = [t["tool"] for t in tool_calls_made]
-                        if "create_order" in tool_names:
-                            # Check if order was created successfully
-                            create_result = next((t["result"] for t in tool_calls_made if t["tool"] == "create_order"), {})
-                            if create_result.get("success"):
-                                order_id = create_result.get("order_id", "")
-                                final_text = f"✅ Order {order_id} created successfully!"
-                            else:
-                                final_text = "⚠️ There was an issue creating the order."
-                        else:
-                            final_text = f"✅ Executed {len(tool_calls_made)} tool(s) successfully!"
-                    else:
-                        final_text = "✅ Task completed!"
-
-                logger.info(f"Returning response: {final_text[:100]}")
-                conversation.add_message("assistant", final_text)
-                return final_text, tool_calls_made
-
-            else:
-                # No function call detected, extract text from parts
-                text_response = ""
-                try:
-                    parts = response.candidates[0].content.parts
-                    logger.info(f"Extracting text from {len(parts)} parts (no function call)")
-
-                    for idx, part in enumerate(parts):
-                        # Double-check no function call in this part
-                        if hasattr(part, 'function_call') and part.function_call:
-                            fc = part.function_call
-                            if hasattr(fc, 'name') and fc.name:
-                                logger.error(f"Part {idx} has function call {fc.name} but was not detected earlier!")
-                                # We missed a function call - handle it now
-                                logger.info("Re-processing response with function call handling")
-                                return self._process_response(response, conversation, chat)
-
-                        # Extract text
-                        if hasattr(part, 'text') and part.text:
-                            logger.info(f"Part {idx} has text: {part.text[:50]}...")
-                            text_response += part.text
-
-                except (ValueError, AttributeError, IndexError) as e:
-                    logger.error(f"Error extracting text from response: {e}")
-
-                # Fallback if no text extracted
-                if not text_response:
-                    logger.warning("No text in response, using fallback")
-                    text_response = "I'm ready to help! What would you like me to do?"
-
-                conversation.add_message("assistant", text_response)
-                return text_response, tool_calls_made
-
-        except Exception as e:
-            logger.error(f"Error processing Gemini response: {e}")
-            error_msg = f"⚠️ Error processing response: {str(e)}"
-            conversation.add_message("assistant", error_msg)
-            return error_msg, tool_calls_made
-
-    def _handle_no_api(self) -> str:
-        """Return error message when API is not available"""
-        return """⚠️ **Gemini API requires Google API key**
-
-To use Gemini:
-
-1. Get an API key from: https://aistudio.google.com/app/apikey
-   - Free tier: 15 requests/min, 1500/day
-   - Or use hackathon credits
-
-2. Add to your `.env` file:
-   ```
-   GOOGLE_API_KEY=your-gemini-key-here
-   ```
-
-3. Restart the application
-
-**Alternative:** Switch to Claude by setting `AI_PROVIDER=anthropic` in .env
-"""
-
-    def get_welcome_message(self) -> str:
-        if not self.api_available:
-            return self._handle_no_api()
-
-        # Don't initialize model yet - wait for first actual message
-        # This allows the welcome message to load instantly
-
-        return """👋 Hello! I'm your AI dispatch assistant powered by **Google Gemini 2.0 Flash**.
-
-I can help you manage your delivery fleet!
-
----
-
-📋 **What I Can Do:**
-
-**1. Create Delivery Orders:**
-• Customer Name
-• Delivery Address
-• Contact (Phone OR Email)
-• Optional: Deadline, Priority, Special Instructions
-
-**2. Query & Search Orders:**
-• Fetch orders with filters (status, priority, payment, etc.)
-• Get complete details of specific orders
-• Search by customer name, phone, email, or order ID
-• Find incomplete/pending orders
-
-**3. Create New Drivers:**
-• Driver Name (required)
-• Optional: Phone, Email, Vehicle Type, License Plate, Skills
-
-**4. Query & Search Drivers:**
-• Fetch drivers with filters (status, vehicle type)
-• Get complete details of specific drivers
-• Search by name, phone, email, plate, or driver ID
-• Find available/active drivers
-
----
-
-**Examples - Just Type Naturally:**
-
-📦 **Create Orders:**
-💬 "Create order for John Doe, 123 Main St San Francisco CA, phone 555-1234, deliver by 5 PM"
-💬 "New urgent delivery to Sarah at 456 Oak Ave NYC, email [email protected]"
-
-🔍 **Query Orders:**
-💬 "Fetch the orders" or "Show me orders"
-💬 "Which orders are incomplete?"
-💬 "Tell me about order ORD-20251114120000"
-💬 "Show me 10 urgent orders"
-💬 "Search for orders from John"
-
-🚚 **Create Drivers:**
-💬 "Add new driver Tom Wilson, phone 555-0101, drives a van, plate ABC-123"
-💬 "Create driver Sarah Martinez with refrigerated truck, phone 555-0202"
-💬 "New driver: Mike Chen, email [email protected], motorcycle delivery"
-
-👥 **Query Drivers:**
-💬 "Show me drivers" or "Fetch the drivers"
-💬 "Which drivers are available?"
-💬 "Tell me about driver DRV-20251114163800"
-💬 "Show 5 active drivers with vans"
-💬 "Search for Tom"
-
----
-
-🚀 **I'll automatically:**
-• Geocode addresses for orders
-• Generate unique IDs
-• Save everything to the database
-• Filter and search across all order fields
-
-What would you like to do?"""

archive/conversation.py

@@ -1,85 +0,0 @@
-"""
-Conversation manager for FleetMind chat
-Handles conversation state and history
-"""
-
-import logging
-from typing import List, Dict
-
-logger = logging.getLogger(__name__)
-
-
-class ConversationManager:
-    """Manage conversation state and history"""
-
-    def __init__(self):
-        self.history = []
-        self.tool_calls = []  # Track all tool calls for transparency
-        self.order_context = {}  # Accumulated order details
-
-    def add_message(self, role: str, content: str):
-        """
-        Add message to conversation history
-
-        Args:
-            role: "user" or "assistant"
-            content: Message content
-        """
-        self.history.append({
-            "role": role,
-            "content": content
-        })
-
-    def add_tool_result(self, tool_name: str, tool_input: dict, tool_result: dict):
-        """
-        Track tool usage for transparency
-
-        Args:
-            tool_name: Name of the tool called
-            tool_input: Input parameters
-            tool_result: Result from tool execution
-        """
-        self.tool_calls.append({
-            "tool": tool_name,
-            "input": tool_input,
-            "result": tool_result
-        })
-
-    def get_history(self) -> List[Dict]:
-        """Get full conversation history"""
-        return self.history
-
-    def get_tool_calls(self) -> List[Dict]:
-        """Get all tool calls made in this conversation"""
-        return self.tool_calls
-
-    def get_last_tool_call(self) -> Dict:
-        """Get the most recent tool call"""
-        if self.tool_calls:
-            return self.tool_calls[-1]
-        return {}
-
-    def clear_tool_calls(self):
-        """Clear tool call history"""
-        self.tool_calls = []
-
-    def reset(self):
-        """Start a new conversation"""
-        self.history = []
-        self.tool_calls = []
-        self.order_context = {}
-        logger.info("Conversation reset")
-
-    def get_message_count(self) -> int:
-        """Get number of messages in conversation"""
-        return len(self.history)
-
-    def get_formatted_history(self) -> List[Dict]:
-        """
-        Get history formatted for Gradio chatbot (messages format)
-
-        Returns:
-            List of message dictionaries with 'role' and 'content' keys
-        """
-        # For Gradio type="messages", return list of dicts with role/content
-        return self.history

archive/old_app.py

@@ -1,28 +0,0 @@
-"""
-FleetMind MCP - Hugging Face Spaces Entry Point
-This is the main entry point for the HF Space deployment
-"""
-
-import sys
-from pathlib import Path
-
-# Add current directory to path
-sys.path.insert(0, str(Path(__file__).parent))
-
-# Import and launch the Gradio app
-from ui.app import create_interface
-
-if __name__ == "__main__":
-    print("=" * 60)
-    print("FleetMind MCP - Starting on Hugging Face Spaces")
-    print("=" * 60)
-
-    # Create and launch the interface
-    app = create_interface()
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        show_api=False  # Disable API docs to avoid schema parsing bug
-    )

archive/ui/ui/__init__.py

@@ -1,4 +0,0 @@
-"""
-UI package for FleetMind
-Contains Gradio interface components
-"""

archive/ui/ui/app.py

@@ -1,1127 +0,0 @@
-"""
-FleetMind MCP - Gradio Web Interface
-Enhanced 3-tab dashboard: Chat, Orders, Drivers
-"""
-
-import sys
-from pathlib import Path
-
-# Add parent directory to path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-import gradio as gr
-from database.connection import execute_query, execute_write, test_connection
-from datetime import datetime, timedelta
-import json
-
-# Import chat functionality
-from chat.chat_engine import ChatEngine
-from chat.conversation import ConversationManager
-from chat.geocoding import GeocodingService
-import uuid
-
-# Global session storage
-SESSIONS = {}
-
-# Initialize chat engine and geocoding service
-chat_engine = ChatEngine()
-geocoding_service = GeocodingService()
-
-# ============================================
-# STATISTICS FUNCTIONS
-# ============================================
-
-def get_orders_stats():
-    """Get order statistics by status"""
-    try:
-        query = """
-            SELECT
-                COUNT(*) as total,
-                COUNT(CASE WHEN status = 'pending' THEN 1 END) as pending,
-                COUNT(CASE WHEN status = 'assigned' THEN 1 END) as assigned,
-                COUNT(CASE WHEN status = 'in_transit' THEN 1 END) as in_transit,
-                COUNT(CASE WHEN status = 'delivered' THEN 1 END) as delivered,
-                COUNT(CASE WHEN status = 'failed' THEN 1 END) as failed,
-                COUNT(CASE WHEN status = 'cancelled' THEN 1 END) as cancelled
-            FROM orders
-        """
-        result = execute_query(query)
-        if result:
-            return result[0]
-        return {"total": 0, "pending": 0, "assigned": 0, "in_transit": 0, "delivered": 0, "failed": 0, "cancelled": 0}
-    except Exception as e:
-        print(f"Error getting order stats: {e}")
-        return {"total": 0, "pending": 0, "assigned": 0, "in_transit": 0, "delivered": 0, "failed": 0, "cancelled": 0}
-
-
-def get_drivers_stats():
-    """Get driver statistics by status"""
-    try:
-        query = """
-            SELECT
-                COUNT(*) as total,
-                COUNT(CASE WHEN status = 'active' THEN 1 END) as active,
-                COUNT(CASE WHEN status = 'busy' THEN 1 END) as busy,
-                COUNT(CASE WHEN status = 'offline' THEN 1 END) as offline,
-                COUNT(CASE WHEN status = 'unavailable' THEN 1 END) as unavailable
-            FROM drivers
-        """
-        result = execute_query(query)
-        if result:
-            return result[0]
-        return {"total": 0, "active": 0, "busy": 0, "offline": 0, "unavailable": 0}
-    except Exception as e:
-        print(f"Error getting driver stats: {e}")
-        return {"total": 0, "active": 0, "busy": 0, "offline": 0, "unavailable": 0}
-
-
-# ============================================
-# ORDERS FUNCTIONS
-# ============================================
-
-def get_all_orders(status_filter="all", priority_filter="all", payment_filter="all", search_term=""):
-    """Get orders with filters"""
-    try:
-        where_clauses = []
-        params = []
-
-        if status_filter and status_filter != "all":
-            where_clauses.append("status = %s")
-            params.append(status_filter)
-
-        if priority_filter and priority_filter != "all":
-            where_clauses.append("priority = %s")
-            params.append(priority_filter)
-
-        if payment_filter and payment_filter != "all":
-            where_clauses.append("payment_status = %s")
-            params.append(payment_filter)
-
-        if search_term:
-            where_clauses.append("(order_id ILIKE %s OR customer_name ILIKE %s OR customer_phone ILIKE %s)")
-            search_pattern = f"%{search_term}%"
-            params.extend([search_pattern, search_pattern, search_pattern])
-
-        where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
-
-        query = f"""
-            SELECT
-                order_id,
-                customer_name,
-                delivery_address,
-                status,
-                priority,
-                assigned_driver_id,
-                time_window_end,
-                created_at
-            FROM orders
-            {where_sql}
-            ORDER BY created_at DESC
-            LIMIT 100
-        """
-
-        results = execute_query(query, tuple(params) if params else ())
-
-        if not results:
-            return [["-", "-", "-", "-", "-", "-", "-"]]
-
-        # Format data for table
-        data = []
-        for row in results:
-            # Truncate address if too long
-            address = row['delivery_address']
-            if len(address) > 40:
-                address = address[:37] + "..."
-
-            # Format deadline
-            deadline = row['time_window_end'].strftime("%Y-%m-%d %H:%M") if row['time_window_end'] else "No deadline"
-
-            # Driver ID or "Unassigned"
-            driver = row['assigned_driver_id'] if row['assigned_driver_id'] else "Unassigned"
-
-            data.append([
-                row['order_id'],
-                row['customer_name'],
-                address,
-                row['status'],
-                row['priority'],
-                driver,
-                deadline
-            ])
-
-        return data
-    except Exception as e:
-        print(f"Error fetching orders: {e}")
-        return [[f"Error: {str(e)}", "", "", "", "", "", ""]]
-
-
-def get_order_details(order_id):
-    """Get complete order details"""
-    if not order_id or order_id == "-":
-        return "Select an order from the table to view details"
-
-    try:
-        query = """
-            SELECT * FROM orders WHERE order_id = %s
-        """
-        results = execute_query(query, (order_id,))
-
-        if not results:
-            return f"Order {order_id} not found"
-
-        order = results[0]
-
-        # Format the details nicely
-        details = f"""
-# Order Details: {order_id}
-
-## Customer Information
-- **Name:** {order['customer_name']}
-- **Phone:** {order['customer_phone'] or 'N/A'}
-- **Email:** {order['customer_email'] or 'N/A'}
-
-## Delivery Information
-- **Address:** {order['delivery_address']}
-- **Coordinates:** ({order['delivery_lat']}, {order['delivery_lng']})
-- **Time Window:** {order['time_window_start']} to {order['time_window_end']}
-
-## Package Details
-- **Weight:** {order['weight_kg'] or 'N/A'} kg
-- **Volume:** {order['volume_m3'] or 'N/A'} m³
-- **Is Fragile:** {"Yes" if order['is_fragile'] else "No"}
-- **Requires Signature:** {"Yes" if order['requires_signature'] else "No"}
-- **Requires Cold Storage:** {"Yes" if order['requires_cold_storage'] else "No"}
-
-## Order Status
-- **Status:** {order['status']}
-- **Priority:** {order['priority']}
-- **Assigned Driver:** {order['assigned_driver_id'] or 'Unassigned'}
-
-## Payment
-- **Order Value:** ${order['order_value'] or '0.00'}
-- **Payment Status:** {order['payment_status']}
-
-## Special Instructions
-{order['special_instructions'] or 'None'}
-
-## Timestamps
-- **Created:** {order['created_at']}
-- **Updated:** {order['updated_at']}
-- **Delivered:** {order['delivered_at'] or 'Not delivered yet'}
-"""
-        return details
-
-    except Exception as e:
-        return f"Error fetching order details: {str(e)}"
-
-
-# ============================================
-# DRIVERS FUNCTIONS
-# ============================================
-
-def get_all_drivers(status_filter="all", vehicle_filter="all", search_term=""):
-    """Get drivers with filters"""
-    try:
-        where_clauses = []
-        params = []
-
-        if status_filter and status_filter != "all":
-            where_clauses.append("status = %s")
-            params.append(status_filter)
-
-        if vehicle_filter and vehicle_filter != "all":
-            where_clauses.append("vehicle_type = %s")
-            params.append(vehicle_filter)
-
-        if search_term:
-            where_clauses.append("(driver_id ILIKE %s OR name ILIKE %s OR phone ILIKE %s OR vehicle_plate ILIKE %s)")
-            search_pattern = f"%{search_term}%"
-            params.extend([search_pattern, search_pattern, search_pattern, search_pattern])
-
-        where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
-
-        query = f"""
-            SELECT
-                driver_id,
-                name,
-                phone,
-                status,
-                vehicle_type,
-                vehicle_plate,
-                current_lat,
-                current_lng,
-                last_location_update
-            FROM drivers
-            {where_sql}
-            ORDER BY name ASC
-            LIMIT 100
-        """
-
-        results = execute_query(query, tuple(params) if params else ())
-
-        if not results:
-            return [["-", "-", "-", "-", "-", "-", "-"]]
-
-        # Format data for table
-        data = []
-        for row in results:
-            # Format location
-            if row['current_lat'] and row['current_lng']:
-                location = f"{row['current_lat']:.4f}, {row['current_lng']:.4f}"
-            else:
-                location = "No location"
-
-            # Format last update
-            last_update = row['last_location_update'].strftime("%Y-%m-%d %H:%M") if row['last_location_update'] else "Never"
-
-            data.append([
-                row['driver_id'],
-                row['name'],
-                row['phone'] or "N/A",
-                row['status'],
-                f"{row['vehicle_type']} - {row['vehicle_plate'] or 'N/A'}",
-                location,
-                last_update
-            ])
-
-        return data
-    except Exception as e:
-        print(f"Error fetching drivers: {e}")
-        return [[f"Error: {str(e)}", "", "", "", "", "", ""]]
-
-
-def get_driver_details(driver_id):
-    """Get complete driver details"""
-    if not driver_id or driver_id == "-":
-        return "Select a driver from the table to view details"
-
-    try:
-        query = """
-            SELECT * FROM drivers WHERE driver_id = %s
-        """
-        results = execute_query(query, (driver_id,))
-
-        if not results:
-            return f"Driver {driver_id} not found"
-
-        driver = results[0]
-
-        # Parse skills (handle both list and JSON string)
-        if driver['skills']:
-            if isinstance(driver['skills'], list):
-                skills = driver['skills']
-            else:
-                skills = json.loads(driver['skills'])
-        else:
-            skills = []
-        skills_str = ", ".join(skills) if skills else "None"
-
-        # Format the details nicely
-        details = f"""
-# Driver Details: {driver_id}
-
-## Personal Information
-- **Name:** {driver['name']}
-- **Phone:** {driver['phone'] or 'N/A'}
-- **Email:** {driver['email'] or 'N/A'}
-
-## Current Location
-- **Coordinates:** ({driver['current_lat']}, {driver['current_lng']})
-- **Last Update:** {driver['last_location_update'] or 'Never updated'}
-
-## Status
-- **Status:** {driver['status']}
-
-## Vehicle Information
-- **Type:** {driver['vehicle_type']}
-- **Plate:** {driver['vehicle_plate'] or 'N/A'}
-- **Capacity (kg):** {driver['capacity_kg'] or 'N/A'}
-- **Capacity (m³):** {driver['capacity_m3'] or 'N/A'}
-
-## Skills & Certifications
-{skills_str}
-
-## Timestamps
-- **Created:** {driver['created_at']}
-- **Updated:** {driver['updated_at']}
-"""
-        return details
-
-    except Exception as e:
-        return f"Error fetching driver details: {str(e)}"
-
-
-def update_order_ui(order_id, **fields):
-    """Update order via UI"""
-    from chat.tools import execute_tool
-
-    if not order_id:
-        return {"success": False, "message": "Order ID is required"}
-
-    # Build tool input
-    tool_input = {"order_id": order_id}
-    tool_input.update(fields)
-
-    # Call update tool
-    result = execute_tool("update_order", tool_input)
-
-    return result
-
-
-def delete_order_ui(order_id):
-    """Delete order via UI"""
-    from chat.tools import execute_tool
-
-    if not order_id:
-        return {"success": False, "message": "Order ID is required"}
-
-    # Call delete tool with confirmation
-    result = execute_tool("delete_order", {"order_id": order_id, "confirm": True})
-
-    return result
-
-
-def update_driver_ui(driver_id, **fields):
-    """Update driver via UI"""
-    from chat.tools import execute_tool
-
-    if not driver_id:
-        return {"success": False, "message": "Driver ID is required"}
-
-    # Build tool input
-    tool_input = {"driver_id": driver_id}
-    tool_input.update(fields)
-
-    # Call update tool
-    result = execute_tool("update_driver", tool_input)
-
-    return result
-
-
-def delete_driver_ui(driver_id):
-    """Delete driver via UI"""
-    from chat.tools import execute_tool
-
-    if not driver_id:
-        return {"success": False, "message": "Driver ID is required"}
-
-    # Call delete tool with confirmation
-    result = execute_tool("delete_driver", {"driver_id": driver_id, "confirm": True})
-
-    return result
-
-
-# ============================================
-# CHAT FUNCTIONS
-# ============================================
-
-def get_api_status():
-    """Get API status for chat"""
-    full_status = chat_engine.get_full_status()
-    selected = full_status["selected"]
-    claude_status = full_status["claude"]["status"]
-    gemini_status = full_status["gemini"]["status"]
-    geocoding_status = geocoding_service.get_status()
-
-    claude_marker = "🎯 **ACTIVE** - " if selected == "anthropic" else ""
-    gemini_marker = "🎯 **ACTIVE** - " if selected == "gemini" else ""
-
-    return f"""**AI Provider:**
-
-**Claude:** {claude_marker}{claude_status}
-**Gemini:** {gemini_marker}{gemini_status}
-
-**Geocoding:** {geocoding_status}
-"""
-
-
-def handle_chat_message(message, session_id):
-    """Handle chat message from user"""
-    if session_id not in SESSIONS:
-        SESSIONS[session_id] = ConversationManager()
-        welcome = chat_engine.get_welcome_message()
-        SESSIONS[session_id].add_message("assistant", welcome)
-
-    conversation = SESSIONS[session_id]
-
-    if not message.strip():
-        return conversation.get_formatted_history(), conversation.get_tool_calls(), session_id
-
-    response, tool_calls = chat_engine.process_message(message, conversation)
-    return conversation.get_formatted_history(), conversation.get_tool_calls(), session_id
-
-
-def reset_conversation(session_id):
-    """Reset conversation to start fresh"""
-    new_session_id = str(uuid.uuid4())
-    new_conversation = ConversationManager()
-    welcome = chat_engine.get_welcome_message()
-    new_conversation.add_message("assistant", welcome)
-    SESSIONS[new_session_id] = new_conversation
-
-    return (
-        new_conversation.get_formatted_history(),
-        [],
-        new_session_id
-    )
-
-
-def get_initial_chat():
-    """Get initial chat state with welcome message"""
-    session_id = str(uuid.uuid4())
-    conversation = ConversationManager()
-    welcome = chat_engine.get_welcome_message()
-    conversation.add_message("assistant", welcome)
-    SESSIONS[session_id] = conversation
-
-    return conversation.get_formatted_history(), [], session_id
-
-
-# ============================================
-# GRADIO INTERFACE
-# ============================================
-
-def create_interface():
-    """Create the Gradio interface with 3 enhanced tabs"""
-
-    with gr.Blocks(theme=gr.themes.Soft(), title="FleetMind Dispatch System") as app:
-
-        gr.Markdown("# 🚚 FleetMind Dispatch System")
-        gr.Markdown("*AI-Powered Delivery Coordination*")
-
-        with gr.Tabs():
-
-            # ==========================================
-            # TAB 1: CHAT
-            # ==========================================
-            with gr.Tab("💬 Chat Assistant"):
-                provider_name = chat_engine.get_provider_name()
-                model_name = chat_engine.get_model_name()
-
-                gr.Markdown(f"### AI Dispatch Assistant")
-                gr.Markdown(f"*Powered by {provider_name} ({model_name})*")
-
-                # Quick Action Buttons
-                gr.Markdown("**Quick Actions:**")
-
-                # Row 1: Create and View
-                with gr.Row():
-                    quick_create_order = gr.Button("📦 Create Order", size="sm")
-                    quick_view_orders = gr.Button("📋 View Orders", size="sm")
-                    quick_view_drivers = gr.Button("👥 View Drivers", size="sm")
-                    quick_check_status = gr.Button("📊 Check Status", size="sm")
-
-                # Row 2: Order Management
-                with gr.Row():
-                    quick_update_order = gr.Button("✏️ Update Order", size="sm", variant="secondary")
-                    quick_delete_order = gr.Button("🗑️ Delete Order", size="sm", variant="secondary")
-                    quick_update_driver = gr.Button("✏️ Update Driver", size="sm", variant="secondary")
-                    quick_delete_driver = gr.Button("🗑️ Delete Driver", size="sm", variant="secondary")
-
-                # Chat interface
-                chatbot = gr.Chatbot(
-                    label="Chat with AI Assistant",
-                    height=600,
-                    type="messages",
-                    show_copy_button=True,
-                    avatar_images=("👤", "🤖")
-                )
-
-                msg_input = gr.Textbox(
-                    placeholder="Type your message here... (e.g., 'Create order for John at 123 Main St' or 'Show me available drivers')",
-                    label="Your Message",
-                    lines=3
-                )
-
-                with gr.Row():
-                    send_btn = gr.Button("📤 Send Message", variant="primary", scale=3)
-                    clear_btn = gr.Button("🗑️ Clear Chat", scale=1)
-
-                # API Status in accordion
-                with gr.Accordion("🔧 System Status", open=False):
-                    api_status = gr.Markdown(get_api_status())
-
-                # Tool usage display
-                with gr.Accordion("🛠️ Tool Usage Log", open=False):
-                    gr.Markdown("*See what tools the AI is using behind the scenes*")
-                    tool_display = gr.JSON(label="Tools Called", value=[])
-
-                # Session state
-                session_id_state = gr.State(value=None)
-
-                # Event handlers
-                def send_message(message, sess_id):
-                    if sess_id is None:
-                        sess_id = str(uuid.uuid4())
-                        SESSIONS[sess_id] = ConversationManager()
-                        welcome = chat_engine.get_welcome_message()
-                        SESSIONS[sess_id].add_message("assistant", welcome)
-
-                    chat_history, tools, new_sess_id = handle_chat_message(message, sess_id)
-                    return chat_history, tools, new_sess_id, ""
-
-                # Quick action functions
-                def quick_action(prompt):
-                    return prompt
-
-                quick_create_order.click(
-                    fn=lambda: "Create a new order",
-                    outputs=msg_input
-                )
-
-                quick_view_orders.click(
-                    fn=lambda: "Show me all orders",
-                    outputs=msg_input
-                )
-
-                quick_view_drivers.click(
-                    fn=lambda: "Show me all available drivers",
-                    outputs=msg_input
-                )
-
-                quick_check_status.click(
-                    fn=lambda: "What is the current status of orders and drivers?",
-                    outputs=msg_input
-                )
-
-                quick_update_order.click(
-                    fn=lambda: "Update order [ORDER_ID] - change status to [STATUS]",
-                    outputs=msg_input
-                )
-
-                quick_delete_order.click(
-                    fn=lambda: "Delete order [ORDER_ID]",
-                    outputs=msg_input
-                )
-
-                quick_update_driver.click(
-                    fn=lambda: "Update driver [DRIVER_ID] - change status to [STATUS]",
-                    outputs=msg_input
-                )
-
-                quick_delete_driver.click(
-                    fn=lambda: "Delete driver [DRIVER_ID]",
-                    outputs=msg_input
-                )
-
-                send_btn.click(
-                    fn=send_message,
-                    inputs=[msg_input, session_id_state],
-                    outputs=[chatbot, tool_display, session_id_state, msg_input]
-                )
-
-                msg_input.submit(
-                    fn=send_message,
-                    inputs=[msg_input, session_id_state],
-                    outputs=[chatbot, tool_display, session_id_state, msg_input]
-                )
-
-                clear_btn.click(
-                    fn=reset_conversation,
-                    inputs=[session_id_state],
-                    outputs=[chatbot, tool_display, session_id_state]
-                )
-
-            # ==========================================
-            # TAB 2: ORDERS
-            # ==========================================
-            with gr.Tab("📦 Orders Management"):
-                gr.Markdown("### Orders Dashboard")
-
-                # Statistics Cards
-                def update_order_stats():
-                    stats = get_orders_stats()
-                    return (
-                        f"**Total:** {stats['total']}",
-                        f"**Pending:** {stats['pending']}",
-                        f"**In Transit:** {stats['in_transit']}",
-                        f"**Delivered:** {stats['delivered']}"
-                    )
-
-                with gr.Row():
-                    stat_total = gr.Markdown("**Total:** 0")
-                    stat_pending = gr.Markdown("**Pending:** 0")
-                    stat_transit = gr.Markdown("**In Transit:** 0")
-                    stat_delivered = gr.Markdown("**Delivered:** 0")
-
-                gr.Markdown("---")
-
-                # Filters
-                gr.Markdown("**Filters:**")
-                with gr.Row():
-                    status_filter = gr.Dropdown(
-                        choices=["all", "pending", "assigned", "in_transit", "delivered", "failed", "cancelled"],
-                        value="all",
-                        label="Status",
-                        scale=1
-                    )
-                    priority_filter = gr.Dropdown(
-                        choices=["all", "standard", "express", "urgent"],
-                        value="all",
-                        label="Priority",
-                        scale=1
-                    )
-                    payment_filter = gr.Dropdown(
-                        choices=["all", "pending", "paid", "cod"],
-                        value="all",
-                        label="Payment",
-                        scale=1
-                    )
-                    search_orders = gr.Textbox(
-                        placeholder="Search by Order ID, Customer, Phone...",
-                        label="Search",
-                        scale=2
-                    )
-
-                with gr.Row():
-                    apply_filters_btn = gr.Button("🔍 Apply Filters", variant="primary", scale=1)
-                    refresh_orders_btn = gr.Button("🔄 Refresh", scale=1)
-
-                # Orders Table
-                orders_table = gr.Dataframe(
-                    headers=["Order ID", "Customer", "Address", "Status", "Priority", "Driver", "Deadline"],
-                    datatype=["str", "str", "str", "str", "str", "str", "str"],
-                    label="Orders List (Click row to view details)",
-                    value=get_all_orders(),
-                    interactive=False,
-                    wrap=True
-                )
-
-                # Order Details
-                gr.Markdown("---")
-                gr.Markdown("**Order Details:**")
-                order_details = gr.Markdown("*Select an order from the table above to view full details*")
-
-                # Edit/Delete Actions
-                gr.Markdown("---")
-                gr.Markdown("**Order Actions:**")
-
-                with gr.Row():
-                    selected_order_id_edit = gr.Textbox(label="Order ID to Edit", placeholder="ORD-XXXXXXXX", scale=2)
-                    edit_order_btn = gr.Button("✏️ Edit Order", variant="secondary", scale=1)
-                    delete_order_btn = gr.Button("🗑️ Delete Order", variant="stop", scale=1)
-
-                # Edit Form (in accordion)
-                with gr.Accordion("Edit Order Form", open=False) as edit_accordion:
-                    with gr.Row():
-                        edit_customer_name = gr.Textbox(label="Customer Name")
-                        edit_customer_phone = gr.Textbox(label="Customer Phone")
-                    with gr.Row():
-                        edit_status = gr.Dropdown(
-                            choices=["pending", "assigned", "in_transit", "delivered", "failed", "cancelled"],
-                            label="Status"
-                        )
-                        edit_priority = gr.Dropdown(
-                            choices=["standard", "express", "urgent"],
-                            label="Priority"
-                        )
-                    with gr.Row():
-                        edit_payment_status = gr.Dropdown(
-                            choices=["pending", "paid", "cod"],
-                            label="Payment Status"
-                        )
-                        edit_weight_kg = gr.Number(label="Weight (kg)")
-                    edit_special_instructions = gr.Textbox(label="Special Instructions", lines=2)
-
-                    save_order_btn = gr.Button("💾 Save Changes", variant="primary")
-
-                # Action Results
-                action_result = gr.Markdown("")
-
-                # Event handlers
-                def filter_and_update_orders(status, priority, payment, search):
-                    return get_all_orders(status, priority, payment, search)
-
-                def refresh_orders_and_stats(status, priority, payment, search):
-                    stats = update_order_stats()
-                    table = get_all_orders(status, priority, payment, search)
-                    return stats[0], stats[1], stats[2], stats[3], table
-
-                def show_order_details(evt: gr.SelectData, table_data):
-                    try:
-                        # table_data is a pandas DataFrame from Gradio
-                        if hasattr(table_data, 'iloc'):
-                            # DataFrame - use iloc to access row and column
-                            order_id = table_data.iloc[evt.index[0], 0]
-                        else:
-                            # List of lists - use standard indexing
-                            order_id = table_data[evt.index[0]][0]
-                        return get_order_details(order_id)
-                    except Exception as e:
-                        return f"Error: {str(e)}"
-
-                apply_filters_btn.click(
-                    fn=filter_and_update_orders,
-                    inputs=[status_filter, priority_filter, payment_filter, search_orders],
-                    outputs=orders_table
-                )
-
-                refresh_orders_btn.click(
-                    fn=refresh_orders_and_stats,
-                    inputs=[status_filter, priority_filter, payment_filter, search_orders],
-                    outputs=[stat_total, stat_pending, stat_transit, stat_delivered, orders_table]
-                )
-
-                orders_table.select(
-                    fn=show_order_details,
-                    inputs=[orders_table],
-                    outputs=order_details
-                )
-
-                # Edit/Delete handlers
-                def handle_edit_order(order_id):
-                    if not order_id:
-                        return "Please enter an Order ID"
-                    # Fetch order details and populate form
-                    query = "SELECT * FROM orders WHERE order_id = %s"
-                    from database.connection import execute_query
-                    results = execute_query(query, (order_id,))
-                    if not results:
-                        return "Order not found"
-                    order = results[0]
-                    return (
-                        order.get('customer_name', ''),
-                        order.get('customer_phone', ''),
-                        order.get('status', ''),
-                        order.get('priority', ''),
-                        order.get('payment_status', ''),
-                        order.get('weight_kg', 0),
-                        order.get('special_instructions', ''),
-                        "Order loaded. Update fields and click Save Changes."
-                    )
-
-                def handle_save_order(order_id, name, phone, status, priority, payment, weight, instructions, status_f, priority_f, payment_f, search):
-                    if not order_id:
-                        return "Please enter an Order ID", get_all_orders(status_f, priority_f, payment_f, search)
-
-                    fields = {}
-                    if name:
-                        fields['customer_name'] = name
-                    if phone:
-                        fields['customer_phone'] = phone
-                    if status:
-                        fields['status'] = status
-                    if priority:
-                        fields['priority'] = priority
-                    if payment:
-                        fields['payment_status'] = payment
-                    if weight:
-                        fields['weight_kg'] = float(weight)
-                    if instructions:
-                        fields['special_instructions'] = instructions
-
-                    result = update_order_ui(order_id, **fields)
-
-                    # Refresh table
-                    refreshed_table = get_all_orders(status_f, priority_f, payment_f, search)
-
-                    if result['success']:
-                        return f"✅ {result['message']}", refreshed_table
-                    else:
-                        return f"❌ {result.get('error', 'Update failed')}", refreshed_table
-
-                def handle_delete_order(order_id, status_f, priority_f, payment_f, search):
-                    if not order_id:
-                        return "Please enter an Order ID", get_all_orders(status_f, priority_f, payment_f, search)
-
-                    result = delete_order_ui(order_id)
-
-                    # Refresh table
-                    refreshed_table = get_all_orders(status_f, priority_f, payment_f, search)
-
-                    if result['success']:
-                        return f"✅ {result['message']}", refreshed_table
-                    else:
-                        return f"❌ {result.get('error', 'Deletion failed')}", refreshed_table
-
-                edit_order_btn.click(
-                    fn=handle_edit_order,
-                    inputs=[selected_order_id_edit],
-                    outputs=[edit_customer_name, edit_customer_phone, edit_status, edit_priority,
-                            edit_payment_status, edit_weight_kg, edit_special_instructions, action_result]
-                )
-
-                save_order_btn.click(
-                    fn=handle_save_order,
-                    inputs=[selected_order_id_edit, edit_customer_name, edit_customer_phone, edit_status,
-                           edit_priority, edit_payment_status, edit_weight_kg, edit_special_instructions,
-                           status_filter, priority_filter, payment_filter, search_orders],
-                    outputs=[action_result, orders_table]
-                )
-
-                delete_order_btn.click(
-                    fn=handle_delete_order,
-                    inputs=[selected_order_id_edit, status_filter, priority_filter, payment_filter, search_orders],
-                    outputs=[action_result, orders_table]
-                )
-
-            # ==========================================
-            # TAB 3: DRIVERS
-            # ==========================================
-            with gr.Tab("👥 Drivers Management"):
-                gr.Markdown("### Drivers Dashboard")
-
-                # Statistics Cards
-                def update_driver_stats():
-                    stats = get_drivers_stats()
-                    return (
-                        f"**Total:** {stats['total']}",
-                        f"**Active:** {stats['active']}",
-                        f"**Busy:** {stats['busy']}",
-                        f"**Offline:** {stats['offline']}"
-                    )
-
-                with gr.Row():
-                    driver_stat_total = gr.Markdown("**Total:** 0")
-                    driver_stat_active = gr.Markdown("**Active:** 0")
-                    driver_stat_busy = gr.Markdown("**Busy:** 0")
-                    driver_stat_offline = gr.Markdown("**Offline:** 0")
-
-                gr.Markdown("---")
-
-                # Filters
-                gr.Markdown("**Filters:**")
-                with gr.Row():
-                    driver_status_filter = gr.Dropdown(
-                        choices=["all", "active", "busy", "offline", "unavailable"],
-                        value="all",
-                        label="Status",
-                        scale=1
-                    )
-                    vehicle_filter = gr.Dropdown(
-                        choices=["all", "van", "truck", "car", "motorcycle"],
-                        value="all",
-                        label="Vehicle Type",
-                        scale=1
-                    )
-                    search_drivers = gr.Textbox(
-                        placeholder="Search by Driver ID, Name, Phone, Plate...",
-                        label="Search",
-                        scale=2
-                    )
-
-                with gr.Row():
-                    apply_driver_filters_btn = gr.Button("🔍 Apply Filters", variant="primary", scale=1)
-                    refresh_drivers_btn = gr.Button("🔄 Refresh", scale=1)
-
-                # Drivers Table
-                drivers_table = gr.Dataframe(
-                    headers=["Driver ID", "Name", "Phone", "Status", "Vehicle", "Location", "Last Update"],
-                    datatype=["str", "str", "str", "str", "str", "str", "str"],
-                    label="Drivers List (Click row to view details)",
-                    value=get_all_drivers(),
-                    interactive=False,
-                    wrap=True
-                )
-
-                # Driver Details
-                gr.Markdown("---")
-                gr.Markdown("**Driver Details:**")
-                driver_details = gr.Markdown("*Select a driver from the table above to view full details*")
-
-                # Edit/Delete Actions
-                gr.Markdown("---")
-                gr.Markdown("**Driver Actions:**")
-
-                with gr.Row():
-                    selected_driver_id_edit = gr.Textbox(label="Driver ID to Edit", placeholder="DRV-XXXXXXXX", scale=2)
-                    edit_driver_btn = gr.Button("✏️ Edit Driver", variant="secondary", scale=1)
-                    delete_driver_btn = gr.Button("🗑️ Delete Driver", variant="stop", scale=1)
-
-                # Edit Form (in accordion)
-                with gr.Accordion("Edit Driver Form", open=False) as driver_edit_accordion:
-                    with gr.Row():
-                        edit_driver_name = gr.Textbox(label="Driver Name")
-                        edit_driver_phone = gr.Textbox(label="Phone")
-                    with gr.Row():
-                        edit_driver_email = gr.Textbox(label="Email")
-                        edit_driver_status = gr.Dropdown(
-                            choices=["active", "busy", "offline", "unavailable"],
-                            label="Status"
-                        )
-                    with gr.Row():
-                        edit_vehicle_type = gr.Textbox(label="Vehicle Type")
-                        edit_vehicle_plate = gr.Textbox(label="Vehicle Plate")
-                    with gr.Row():
-                        edit_capacity_kg = gr.Number(label="Capacity (kg)")
-                        edit_capacity_m3 = gr.Number(label="Capacity (m³)")
-
-                    save_driver_btn = gr.Button("💾 Save Changes", variant="primary")
-
-                # Action Results
-                driver_action_result = gr.Markdown("")
-
-                # Event handlers
-                def filter_and_update_drivers(status, vehicle, search):
-                    return get_all_drivers(status, vehicle, search)
-
-                def refresh_drivers_and_stats(status, vehicle, search):
-                    stats = update_driver_stats()
-                    table = get_all_drivers(status, vehicle, search)
-                    return stats[0], stats[1], stats[2], stats[3], table
-
-                def show_driver_details(evt: gr.SelectData, table_data):
-                    try:
-                        # table_data is a pandas DataFrame from Gradio
-                        if hasattr(table_data, 'iloc'):
-                            # DataFrame - use iloc to access row and column
-                            driver_id = table_data.iloc[evt.index[0], 0]
-                        else:
-                            # List of lists - use standard indexing
-                            driver_id = table_data[evt.index[0]][0]
-                        return get_driver_details(driver_id)
-                    except Exception as e:
-                        return f"Error: {str(e)}"
-
-                apply_driver_filters_btn.click(
-                    fn=filter_and_update_drivers,
-                    inputs=[driver_status_filter, vehicle_filter, search_drivers],
-                    outputs=drivers_table
-                )
-
-                refresh_drivers_btn.click(
-                    fn=refresh_drivers_and_stats,
-                    inputs=[driver_status_filter, vehicle_filter, search_drivers],
-                    outputs=[driver_stat_total, driver_stat_active, driver_stat_busy, driver_stat_offline, drivers_table]
-                )
-
-                drivers_table.select(
-                    fn=show_driver_details,
-                    inputs=[drivers_table],
-                    outputs=driver_details
-                )
-
-                # Edit/Delete handlers
-                def handle_edit_driver(driver_id):
-                    if not driver_id:
-                        return "Please enter a Driver ID"
-                    # Fetch driver details and populate form
-                    query = "SELECT * FROM drivers WHERE driver_id = %s"
-                    from database.connection import execute_query
-                    results = execute_query(query, (driver_id,))
-                    if not results:
-                        return "Driver not found"
-                    driver = results[0]
-                    return (
-                        driver.get('name', ''),
-                        driver.get('phone', ''),
-                        driver.get('email', ''),
-                        driver.get('status', ''),
-                        driver.get('vehicle_type', ''),
-                        driver.get('vehicle_plate', ''),
-                        driver.get('capacity_kg', 0),
-                        driver.get('capacity_m3', 0),
-                        "Driver loaded. Update fields and click Save Changes."
-                    )
-
-                def handle_save_driver(driver_id, name, phone, email, status, vehicle_type, vehicle_plate, capacity_kg, capacity_m3, status_f, vehicle_f, search):
-                    if not driver_id:
-                        return "Please enter a Driver ID", get_all_drivers(status_f, vehicle_f, search)
-
-                    fields = {}
-                    if name:
-                        fields['name'] = name
-                    if phone:
-                        fields['phone'] = phone
-                    if email:
-                        fields['email'] = email
-                    if status:
-                        fields['status'] = status
-                    if vehicle_type:
-                        fields['vehicle_type'] = vehicle_type
-                    if vehicle_plate:
-                        fields['vehicle_plate'] = vehicle_plate
-                    if capacity_kg:
-                        fields['capacity_kg'] = float(capacity_kg)
-                    if capacity_m3:
-                        fields['capacity_m3'] = float(capacity_m3)
-
-                    result = update_driver_ui(driver_id, **fields)
-
-                    # Refresh table
-                    refreshed_table = get_all_drivers(status_f, vehicle_f, search)
-
-                    if result['success']:
-                        return f"✅ {result['message']}", refreshed_table
-                    else:
-                        return f"❌ {result.get('error', 'Update failed')}", refreshed_table
-
-                def handle_delete_driver(driver_id, status_f, vehicle_f, search):
-                    if not driver_id:
-                        return "Please enter a Driver ID", get_all_drivers(status_f, vehicle_f, search)
-
-                    result = delete_driver_ui(driver_id)
-
-                    # Refresh table
-                    refreshed_table = get_all_drivers(status_f, vehicle_f, search)
-
-                    if result['success']:
-                        return f"✅ {result['message']}", refreshed_table
-                    else:
-                        return f"❌ {result.get('error', 'Deletion failed')}", refreshed_table
-
-                edit_driver_btn.click(
-                    fn=handle_edit_driver,
-                    inputs=[selected_driver_id_edit],
-                    outputs=[edit_driver_name, edit_driver_phone, edit_driver_email, edit_driver_status,
-                            edit_vehicle_type, edit_vehicle_plate, edit_capacity_kg, edit_capacity_m3, driver_action_result]
-                )
-
-                save_driver_btn.click(
-                    fn=handle_save_driver,
-                    inputs=[selected_driver_id_edit, edit_driver_name, edit_driver_phone, edit_driver_email,
-                           edit_driver_status, edit_vehicle_type, edit_vehicle_plate, edit_capacity_kg, edit_capacity_m3,
-                           driver_status_filter, vehicle_filter, search_drivers],
-                    outputs=[driver_action_result, drivers_table]
-                )
-
-                delete_driver_btn.click(
-                    fn=handle_delete_driver,
-                    inputs=[selected_driver_id_edit, driver_status_filter, vehicle_filter, search_drivers],
-                    outputs=[driver_action_result, drivers_table]
-                )
-
-        gr.Markdown("---")
-        gr.Markdown("*FleetMind v1.0 - AI-Powered Dispatch Coordination*")
-
-        # Initialize chat and stats on load
-        app.load(
-            fn=get_initial_chat,
-            outputs=[chatbot, tool_display, session_id_state]
-        ).then(
-            fn=update_order_stats,
-            outputs=[stat_total, stat_pending, stat_transit, stat_delivered]
-        ).then(
-            fn=update_driver_stats,
-            outputs=[driver_stat_total, driver_stat_active, driver_stat_busy, driver_stat_offline]
-        )
-
-    return app
-
-
-# ============================================
-# MAIN
-# ============================================
-
-if __name__ == "__main__":
-    print("=" * 60)
-    print("FleetMind - Starting Enhanced UI")
-    print("=" * 60)
-
-    print("\nChecking database connection...")
-    if test_connection():
-        print("✅ Database connected")
-    else:
-        print("❌ Database connection failed")
-
-    print("\nStarting Gradio interface...")
-    print("=" * 60)
-
-    app = create_interface()
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        show_api=False
-    )