Add new tools for driver and order management

- Implemented `create_driver` tool for onboarding new drivers with detailed input schema.
- Added `count_orders`, `fetch_orders`, `get_order_details`, `search_orders`, and `get_incomplete_orders` tools for order management.
- Introduced `count_drivers`, `fetch_drivers`, `get_driver_details`, `search_drivers`, and `get_available_drivers` tools for driver management.
- Enhanced `execute_tool` function to handle new tools and their respective logic.
- Added database query handling for counting and fetching orders and drivers with optional filters, pagination, and sorting.

chat/providers/claude_provider.py

@@ -40,7 +40,7 @@ class ClaudeProvider(AIProvider):
 
     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 delivery orders efficiently.
+        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:**
 
@@ -63,7 +63,7 @@ Please provide the following details:
 
 ---
 
-**Your Workflow:**
+**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
@@ -72,14 +72,83 @@ Please provide the following details:
    - 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 are successfully created
+- 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 create orders FAST!"""
+Remember: Dispatch coordinators are busy - help them work efficiently!"""
 
     def is_available(self) -> bool:
         return self.api_available
@@ -243,7 +312,7 @@ To use Claude:
 
         return """👋 Hello! I'm your AI dispatch assistant powered by **Claude Sonnet 3.5**.
 
-I can help you create delivery orders quickly and efficiently!
+I can help you create and query delivery orders and drivers quickly and efficiently!
 
 ---
 
@@ -262,13 +331,42 @@ I can help you create delivery orders quickly and efficiently!
 
 ---
 
+🔍 **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:**
 
-✅ *Complete:* "Create order for John Doe, 123 Main St San Francisco CA, phone 555-1234, deliver by 5 PM"
+✅ **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"
 
-✅ *Partial:* "I need a delivery for Sarah" *(I'll ask for missing details)*
+✅ **Create Driver:** "Add driver Tom Wilson, phone 555-0101, drives a van, plate ABC-123"
 
-✅ *Natural:* "Urgent package to [email protected] at 456 Market Street"
+✅ **Query Drivers:** "Show me drivers" or "Which drivers are available?"
 
 ---
 

chat/providers/gemini_provider.py

@@ -78,10 +78,28 @@ 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 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 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
+- 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
@@ -90,7 +108,85 @@ Optional: time_window_end, priority (standard/express/urgent), special_instructi
 Required: name
 Optional: phone, email, vehicle_type (van/truck/car/motorcycle), vehicle_plate, capacity_kg, capacity_m3, skills (list), status (active/busy/offline)
 
-**Your goal:** Execute tasks in ONE smooth automated flow. No stopping, no intermediate messages!"""
+**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"""
@@ -208,6 +304,234 @@ Optional: phone, email, vehicle_type (van/truck/car/motorcycle), vehicle_plate,
                             },
                             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. Use when user asks 'tell me about driver X' or wants detailed information about a specific driver.",
+                        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=[]
+                        )
                     )
                 ]
             )
@@ -331,7 +655,7 @@ Optional: phone, email, vehicle_type (van/truck/car/motorcycle), vehicle_plate,
             if has_function_call:
                 # Handle function calls (potentially multiple in sequence)
                 current_response = response
-                max_iterations = 10  # Allow more iterations for complex tasks
+                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
@@ -528,28 +852,55 @@ I can help you manage your delivery fleet!
 • Contact (Phone OR Email)
 • Optional: Deadline, Priority, Special Instructions
 
-**2. Add New Drivers:**
+**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:**
 
-📦 **Orders:**
+📦 **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]"
 
-🚚 **Drivers:**
+🔍 **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?"""

chat/tools.py

@@ -11,7 +11,7 @@ import logging
 # Add parent directory to path
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-from database.connection import execute_write
+from database.connection import execute_write, execute_query
 from chat.geocoding import GeocodingService
 
 logger = logging.getLogger(__name__)
@@ -85,6 +85,296 @@ TOOLS_SCHEMA = [
             },
             "required": ["customer_name", "delivery_address", "delivery_lat", "delivery_lng"]
         }
+    },
+    {
+        "name": "create_driver",
+        "description": "Create a new delivery driver in the database. Use this to onboard new drivers to the fleet.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": "Full name of the driver"
+                },
+                "phone": {
+                    "type": "string",
+                    "description": "Driver phone number (optional)"
+                },
+                "email": {
+                    "type": "string",
+                    "description": "Driver email address (optional)"
+                },
+                "vehicle_type": {
+                    "type": "string",
+                    "description": "Type of vehicle: van, truck, car, motorcycle (default: van)"
+                },
+                "vehicle_plate": {
+                    "type": "string",
+                    "description": "Vehicle license plate number (optional)"
+                },
+                "capacity_kg": {
+                    "type": "number",
+                    "description": "Vehicle cargo capacity in kilograms (default: 1000.0)"
+                },
+                "capacity_m3": {
+                    "type": "number",
+                    "description": "Vehicle cargo volume in cubic meters (default: 12.0)"
+                },
+                "skills": {
+                    "type": "array",
+                    "description": "List of driver skills/certifications: refrigerated, medical_certified, fragile_handler, overnight, express_delivery",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "status": {
+                    "type": "string",
+                    "enum": ["active", "busy", "offline", "unavailable"],
+                    "description": "Driver status (default: active)"
+                }
+            },
+            "required": ["name"]
+        }
+    },
+    {
+        "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.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "status": {
+                    "type": "string",
+                    "enum": ["pending", "assigned", "in_transit", "delivered", "failed", "cancelled"],
+                    "description": "Filter by order status (optional)"
+                },
+                "priority": {
+                    "type": "string",
+                    "enum": ["standard", "express", "urgent"],
+                    "description": "Filter by priority level (optional)"
+                },
+                "payment_status": {
+                    "type": "string",
+                    "enum": ["pending", "paid", "cod"],
+                    "description": "Filter by payment status (optional)"
+                },
+                "assigned_driver_id": {
+                    "type": "string",
+                    "description": "Filter by assigned driver ID (optional)"
+                },
+                "is_fragile": {
+                    "type": "boolean",
+                    "description": "Filter fragile packages only (optional)"
+                },
+                "requires_signature": {
+                    "type": "boolean",
+                    "description": "Filter orders requiring signature (optional)"
+                },
+                "requires_cold_storage": {
+                    "type": "boolean",
+                    "description": "Filter orders requiring cold storage (optional)"
+                }
+            },
+            "required": []
+        }
+    },
+    {
+        "name": "fetch_orders",
+        "description": "Fetch orders from the database with optional filters, pagination, and sorting. Use after counting to show specific number of orders.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of orders to fetch (default: 10, max: 100)"
+                },
+                "offset": {
+                    "type": "integer",
+                    "description": "Number of orders to skip for pagination (default: 0)"
+                },
+                "status": {
+                    "type": "string",
+                    "enum": ["pending", "assigned", "in_transit", "delivered", "failed", "cancelled"],
+                    "description": "Filter by order status (optional)"
+                },
+                "priority": {
+                    "type": "string",
+                    "enum": ["standard", "express", "urgent"],
+                    "description": "Filter by priority level (optional)"
+                },
+                "payment_status": {
+                    "type": "string",
+                    "enum": ["pending", "paid", "cod"],
+                    "description": "Filter by payment status (optional)"
+                },
+                "assigned_driver_id": {
+                    "type": "string",
+                    "description": "Filter by assigned driver ID (optional)"
+                },
+                "is_fragile": {
+                    "type": "boolean",
+                    "description": "Filter fragile packages only (optional)"
+                },
+                "requires_signature": {
+                    "type": "boolean",
+                    "description": "Filter orders requiring signature (optional)"
+                },
+                "requires_cold_storage": {
+                    "type": "boolean",
+                    "description": "Filter orders requiring cold storage (optional)"
+                },
+                "sort_by": {
+                    "type": "string",
+                    "enum": ["created_at", "priority", "time_window_start"],
+                    "description": "Field to sort by (default: created_at)"
+                },
+                "sort_order": {
+                    "type": "string",
+                    "enum": ["ASC", "DESC"],
+                    "description": "Sort order (default: DESC for newest first)"
+                }
+            },
+            "required": []
+        }
+    },
+    {
+        "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.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "order_id": {
+                    "type": "string",
+                    "description": "The order ID to fetch details for (e.g., 'ORD-20251114163800')"
+                }
+            },
+            "required": ["order_id"]
+        }
+    },
+    {
+        "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.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "search_term": {
+                    "type": "string",
+                    "description": "Search term to match against customer_name, customer_email, customer_phone, or order_id"
+                }
+            },
+            "required": ["search_term"]
+        }
+    },
+    {
+        "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).",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of orders to fetch (default: 20)"
+                }
+            },
+            "required": []
+        }
+    },
+    {
+        "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.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "status": {
+                    "type": "string",
+                    "enum": ["active", "busy", "offline", "unavailable"],
+                    "description": "Filter by driver status (optional)"
+                },
+                "vehicle_type": {
+                    "type": "string",
+                    "description": "Filter by vehicle type: van, truck, car, motorcycle, etc. (optional)"
+                }
+            },
+            "required": []
+        }
+    },
+    {
+        "name": "fetch_drivers",
+        "description": "Fetch drivers from the database with optional filters, pagination, and sorting. Use after counting to show specific number of drivers.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of drivers to fetch (default: 10, max: 100)"
+                },
+                "offset": {
+                    "type": "integer",
+                    "description": "Number of drivers to skip for pagination (default: 0)"
+                },
+                "status": {
+                    "type": "string",
+                    "enum": ["active", "busy", "offline", "unavailable"],
+                    "description": "Filter by driver status (optional)"
+                },
+                "vehicle_type": {
+                    "type": "string",
+                    "description": "Filter by vehicle type: van, truck, car, motorcycle, etc. (optional)"
+                },
+                "sort_by": {
+                    "type": "string",
+                    "enum": ["name", "status", "created_at", "last_location_update"],
+                    "description": "Field to sort by (default: name)"
+                },
+                "sort_order": {
+                    "type": "string",
+                    "enum": ["ASC", "DESC"],
+                    "description": "Sort order (default: ASC for alphabetical)"
+                }
+            },
+            "required": []
+        }
+    },
+    {
+        "name": "get_driver_details",
+        "description": "Get complete details of a specific driver by driver ID. Use when user asks 'tell me about driver X' or wants detailed information about a specific driver.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "driver_id": {
+                    "type": "string",
+                    "description": "The driver ID to fetch details for (e.g., 'DRV-20251114163800')"
+                }
+            },
+            "required": ["driver_id"]
+        }
+    },
+    {
+        "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.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "search_term": {
+                    "type": "string",
+                    "description": "Search term to match against name, email, phone, vehicle_plate, or driver_id"
+                }
+            },
+            "required": ["search_term"]
+        }
+    },
+    {
+        "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.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of drivers to fetch (default: 20)"
+                }
+            },
+            "required": []
+        }
     }
 ]
 
@@ -107,6 +397,26 @@ def execute_tool(tool_name: str, tool_input: dict) -> dict:
             return handle_create_order(tool_input)
         elif tool_name == "create_driver":
             return handle_create_driver(tool_input)
+        elif tool_name == "count_orders":
+            return handle_count_orders(tool_input)
+        elif tool_name == "fetch_orders":
+            return handle_fetch_orders(tool_input)
+        elif tool_name == "get_order_details":
+            return handle_get_order_details(tool_input)
+        elif tool_name == "search_orders":
+            return handle_search_orders(tool_input)
+        elif tool_name == "get_incomplete_orders":
+            return handle_get_incomplete_orders(tool_input)
+        elif tool_name == "count_drivers":
+            return handle_count_drivers(tool_input)
+        elif tool_name == "fetch_drivers":
+            return handle_fetch_drivers(tool_input)
+        elif tool_name == "get_driver_details":
+            return handle_get_driver_details(tool_input)
+        elif tool_name == "search_drivers":
+            return handle_search_drivers(tool_input)
+        elif tool_name == "get_available_drivers":
+            return handle_get_available_drivers(tool_input)
         else:
             return {
                 "success": False,
@@ -337,6 +647,925 @@ def handle_create_driver(tool_input: dict) -> dict:
         }
 
 
+def handle_count_orders(tool_input: dict) -> dict:
+    """
+    Execute count orders tool
+
+    Args:
+        tool_input: Dict with optional filter fields
+
+    Returns:
+        Order count result with breakdown
+    """
+    # Build WHERE clause based on filters
+    where_clauses = []
+    params = []
+
+    if "status" in tool_input:
+        where_clauses.append("status = %s")
+        params.append(tool_input["status"])
+
+    if "priority" in tool_input:
+        where_clauses.append("priority = %s")
+        params.append(tool_input["priority"])
+
+    if "payment_status" in tool_input:
+        where_clauses.append("payment_status = %s")
+        params.append(tool_input["payment_status"])
+
+    if "assigned_driver_id" in tool_input:
+        where_clauses.append("assigned_driver_id = %s")
+        params.append(tool_input["assigned_driver_id"])
+
+    if "is_fragile" in tool_input:
+        where_clauses.append("is_fragile = %s")
+        params.append(tool_input["is_fragile"])
+
+    if "requires_signature" in tool_input:
+        where_clauses.append("requires_signature = %s")
+        params.append(tool_input["requires_signature"])
+
+    if "requires_cold_storage" in tool_input:
+        where_clauses.append("requires_cold_storage = %s")
+        params.append(tool_input["requires_cold_storage"])
+
+    where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
+
+    # Total count query
+    count_query = f"SELECT COUNT(*) as total FROM orders{where_sql}"
+
+    # Breakdown by status query
+    breakdown_query = f"""
+        SELECT status, COUNT(*) as count
+        FROM orders{where_sql}
+        GROUP BY status
+        ORDER BY count DESC
+    """
+
+    # Breakdown by priority query
+    priority_query = f"""
+        SELECT priority, COUNT(*) as count
+        FROM orders{where_sql}
+        GROUP BY priority
+        ORDER BY CASE priority
+            WHEN 'urgent' THEN 1
+            WHEN 'express' THEN 2
+            WHEN 'standard' THEN 3
+        END
+    """
+
+    try:
+        # Execute queries
+        total_result = execute_query(count_query, tuple(params) if params else None)
+        total = total_result[0]['total'] if total_result else 0
+
+        status_result = execute_query(breakdown_query, tuple(params) if params else None)
+        priority_result = execute_query(priority_query, tuple(params) if params else None)
+
+        # Format breakdown
+        status_breakdown = {row['status']: row['count'] for row in status_result} if status_result else {}
+        priority_breakdown = {row['priority']: row['count'] for row in priority_result} if priority_result else {}
+
+        logger.info(f"Counted orders: {total} total")
+
+        return {
+            "success": True,
+            "total": total,
+            "status_breakdown": status_breakdown,
+            "priority_breakdown": priority_breakdown,
+            "message": f"Found {total} order(s)"
+        }
+    except Exception as e:
+        logger.error(f"Database error counting orders: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to count orders: {str(e)}"
+        }
+
+
+def handle_fetch_orders(tool_input: dict) -> dict:
+    """
+    Execute fetch orders tool
+
+    Args:
+        tool_input: Dict with filter, pagination, and sorting options
+
+    Returns:
+        List of orders matching criteria
+    """
+    # Extract pagination and sorting
+    limit = min(tool_input.get("limit", 10), 100)  # Cap at 100
+    offset = tool_input.get("offset", 0)
+    sort_by = tool_input.get("sort_by", "created_at")
+    sort_order = tool_input.get("sort_order", "DESC")
+
+    # Build WHERE clause based on filters
+    where_clauses = []
+    params = []
+
+    if "status" in tool_input:
+        where_clauses.append("status = %s")
+        params.append(tool_input["status"])
+
+    if "priority" in tool_input:
+        where_clauses.append("priority = %s")
+        params.append(tool_input["priority"])
+
+    if "payment_status" in tool_input:
+        where_clauses.append("payment_status = %s")
+        params.append(tool_input["payment_status"])
+
+    if "assigned_driver_id" in tool_input:
+        where_clauses.append("assigned_driver_id = %s")
+        params.append(tool_input["assigned_driver_id"])
+
+    if "is_fragile" in tool_input:
+        where_clauses.append("is_fragile = %s")
+        params.append(tool_input["is_fragile"])
+
+    if "requires_signature" in tool_input:
+        where_clauses.append("requires_signature = %s")
+        params.append(tool_input["requires_signature"])
+
+    if "requires_cold_storage" in tool_input:
+        where_clauses.append("requires_cold_storage = %s")
+        params.append(tool_input["requires_cold_storage"])
+
+    where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
+
+    # Build query
+    query = f"""
+        SELECT
+            order_id, customer_name, customer_phone, customer_email,
+            delivery_address, delivery_lat, delivery_lng,
+            time_window_start, time_window_end,
+            priority, weight_kg, volume_m3, special_instructions,
+            status, assigned_driver_id,
+            created_at, updated_at, delivered_at,
+            order_value, payment_status,
+            requires_signature, is_fragile, requires_cold_storage
+        FROM orders
+        {where_sql}
+        ORDER BY {sort_by} {sort_order}
+        LIMIT %s OFFSET %s
+    """
+
+    params.extend([limit, offset])
+
+    try:
+        results = execute_query(query, tuple(params))
+
+        if not results:
+            return {
+                "success": True,
+                "orders": [],
+                "count": 0,
+                "message": "No orders found matching criteria"
+            }
+
+        # Format orders for readability
+        orders = []
+        for row in results:
+            order = {
+                "order_id": row['order_id'],
+                "customer": {
+                    "name": row['customer_name'],
+                    "phone": row['customer_phone'],
+                    "email": row['customer_email']
+                },
+                "delivery": {
+                    "address": row['delivery_address'],
+                    "latitude": float(row['delivery_lat']) if row['delivery_lat'] else None,
+                    "longitude": float(row['delivery_lng']) if row['delivery_lng'] else None
+                },
+                "time_window": {
+                    "start": str(row['time_window_start']) if row['time_window_start'] else None,
+                    "end": str(row['time_window_end']) if row['time_window_end'] else None
+                },
+                "details": {
+                    "priority": row['priority'],
+                    "status": row['status'],
+                    "weight_kg": float(row['weight_kg']) if row['weight_kg'] else None,
+                    "volume_m3": float(row['volume_m3']) if row['volume_m3'] else None,
+                    "special_instructions": row['special_instructions']
+                },
+                "flags": {
+                    "requires_signature": row['requires_signature'],
+                    "is_fragile": row['is_fragile'],
+                    "requires_cold_storage": row['requires_cold_storage']
+                },
+                "payment": {
+                    "order_value": float(row['order_value']) if row['order_value'] else None,
+                    "payment_status": row['payment_status']
+                },
+                "assigned_driver_id": row['assigned_driver_id'],
+                "timestamps": {
+                    "created_at": str(row['created_at']),
+                    "updated_at": str(row['updated_at']) if row['updated_at'] else None,
+                    "delivered_at": str(row['delivered_at']) if row['delivered_at'] else None
+                }
+            }
+            orders.append(order)
+
+        logger.info(f"Fetched {len(orders)} orders")
+
+        return {
+            "success": True,
+            "orders": orders,
+            "count": len(orders),
+            "message": f"Retrieved {len(orders)} order(s)"
+        }
+    except Exception as e:
+        logger.error(f"Database error fetching orders: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to fetch orders: {str(e)}"
+        }
+
+
+def handle_get_order_details(tool_input: dict) -> dict:
+    """
+    Execute get order details tool
+
+    Args:
+        tool_input: Dict with order_id
+
+    Returns:
+        Complete order details
+    """
+    order_id = tool_input.get("order_id")
+
+    if not order_id:
+        return {
+            "success": False,
+            "error": "order_id is required"
+        }
+
+    query = """
+        SELECT
+            order_id, customer_name, customer_phone, customer_email,
+            pickup_address, pickup_lat, pickup_lng,
+            delivery_address, delivery_lat, delivery_lng,
+            time_window_start, time_window_end,
+            priority, weight_kg, volume_m3, special_instructions,
+            status, assigned_driver_id,
+            created_at, updated_at, delivered_at,
+            order_value, payment_status,
+            requires_signature, is_fragile, requires_cold_storage
+        FROM orders
+        WHERE order_id = %s
+    """
+
+    try:
+        results = execute_query(query, (order_id,))
+
+        if not results:
+            return {
+                "success": False,
+                "error": f"Order {order_id} not found"
+            }
+
+        row = results[0]
+
+        order = {
+            "order_id": row['order_id'],
+            "customer": {
+                "name": row['customer_name'],
+                "phone": row['customer_phone'],
+                "email": row['customer_email']
+            },
+            "pickup": {
+                "address": row['pickup_address'],
+                "latitude": float(row['pickup_lat']) if row['pickup_lat'] else None,
+                "longitude": float(row['pickup_lng']) if row['pickup_lng'] else None
+            } if row['pickup_address'] else None,
+            "delivery": {
+                "address": row['delivery_address'],
+                "latitude": float(row['delivery_lat']) if row['delivery_lat'] else None,
+                "longitude": float(row['delivery_lng']) if row['delivery_lng'] else None
+            },
+            "time_window": {
+                "start": str(row['time_window_start']) if row['time_window_start'] else None,
+                "end": str(row['time_window_end']) if row['time_window_end'] else None
+            },
+            "details": {
+                "priority": row['priority'],
+                "status": row['status'],
+                "weight_kg": float(row['weight_kg']) if row['weight_kg'] else None,
+                "volume_m3": float(row['volume_m3']) if row['volume_m3'] else None,
+                "special_instructions": row['special_instructions']
+            },
+            "flags": {
+                "requires_signature": row['requires_signature'],
+                "is_fragile": row['is_fragile'],
+                "requires_cold_storage": row['requires_cold_storage']
+            },
+            "payment": {
+                "order_value": float(row['order_value']) if row['order_value'] else None,
+                "payment_status": row['payment_status']
+            },
+            "assigned_driver_id": row['assigned_driver_id'],
+            "timestamps": {
+                "created_at": str(row['created_at']),
+                "updated_at": str(row['updated_at']) if row['updated_at'] else None,
+                "delivered_at": str(row['delivered_at']) if row['delivered_at'] else None
+            }
+        }
+
+        logger.info(f"Retrieved details for order: {order_id}")
+
+        return {
+            "success": True,
+            "order": order,
+            "message": f"Order {order_id} details retrieved"
+        }
+    except Exception as e:
+        logger.error(f"Database error getting order details: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to get order details: {str(e)}"
+        }
+
+
+def handle_search_orders(tool_input: dict) -> dict:
+    """
+    Execute search orders tool
+
+    Args:
+        tool_input: Dict with search_term
+
+    Returns:
+        List of matching orders
+    """
+    search_term = tool_input.get("search_term", "").strip()
+
+    if not search_term:
+        return {
+            "success": False,
+            "error": "search_term is required"
+        }
+
+    query = """
+        SELECT
+            order_id, customer_name, customer_phone, customer_email,
+            delivery_address, priority, status, created_at
+        FROM orders
+        WHERE
+            order_id ILIKE %s OR
+            customer_name ILIKE %s OR
+            customer_email ILIKE %s OR
+            customer_phone ILIKE %s
+        ORDER BY created_at DESC
+        LIMIT 50
+    """
+
+    search_pattern = f"%{search_term}%"
+    params = (search_pattern, search_pattern, search_pattern, search_pattern)
+
+    try:
+        results = execute_query(query, params)
+
+        if not results:
+            return {
+                "success": True,
+                "orders": [],
+                "count": 0,
+                "message": f"No orders found matching '{search_term}'"
+            }
+
+        orders = []
+        for row in results:
+            orders.append({
+                "order_id": row['order_id'],
+                "customer_name": row['customer_name'],
+                "customer_phone": row['customer_phone'],
+                "customer_email": row['customer_email'],
+                "delivery_address": row['delivery_address'],
+                "priority": row['priority'],
+                "status": row['status'],
+                "created_at": str(row['created_at'])
+            })
+
+        logger.info(f"Search '{search_term}' found {len(orders)} orders")
+
+        return {
+            "success": True,
+            "orders": orders,
+            "count": len(orders),
+            "message": f"Found {len(orders)} order(s) matching '{search_term}'"
+        }
+    except Exception as e:
+        logger.error(f"Database error searching orders: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to search orders: {str(e)}"
+        }
+
+
+def handle_get_incomplete_orders(tool_input: dict) -> dict:
+    """
+    Execute get incomplete orders tool
+
+    Args:
+        tool_input: Dict with optional limit
+
+    Returns:
+        List of incomplete orders (pending, assigned, in_transit)
+    """
+    limit = min(tool_input.get("limit", 20), 100)
+
+    query = """
+        SELECT
+            order_id, customer_name, delivery_address,
+            priority, status, time_window_end, created_at,
+            assigned_driver_id
+        FROM orders
+        WHERE status IN ('pending', 'assigned', 'in_transit')
+        ORDER BY
+            CASE priority
+                WHEN 'urgent' THEN 1
+                WHEN 'express' THEN 2
+                WHEN 'standard' THEN 3
+            END,
+            time_window_end ASC
+        LIMIT %s
+    """
+
+    try:
+        results = execute_query(query, (limit,))
+
+        if not results:
+            return {
+                "success": True,
+                "orders": [],
+                "count": 0,
+                "message": "No incomplete orders found"
+            }
+
+        orders = []
+        for row in results:
+            orders.append({
+                "order_id": row['order_id'],
+                "customer_name": row['customer_name'],
+                "delivery_address": row['delivery_address'],
+                "priority": row['priority'],
+                "status": row['status'],
+                "time_window_end": str(row['time_window_end']) if row['time_window_end'] else None,
+                "created_at": str(row['created_at']),
+                "assigned_driver_id": row['assigned_driver_id']
+            })
+
+        logger.info(f"Retrieved {len(orders)} incomplete orders")
+
+        return {
+            "success": True,
+            "orders": orders,
+            "count": len(orders),
+            "message": f"Found {len(orders)} incomplete order(s)"
+        }
+    except Exception as e:
+        logger.error(f"Database error getting incomplete orders: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to get incomplete orders: {str(e)}"
+        }
+
+
+def handle_count_drivers(tool_input: dict) -> dict:
+    """
+    Execute count drivers tool
+
+    Args:
+        tool_input: Dict with optional filter fields
+
+    Returns:
+        Driver count result with breakdown
+    """
+    # Build WHERE clause based on filters
+    where_clauses = []
+    params = []
+
+    if "status" in tool_input:
+        where_clauses.append("status = %s")
+        params.append(tool_input["status"])
+
+    if "vehicle_type" in tool_input:
+        where_clauses.append("vehicle_type = %s")
+        params.append(tool_input["vehicle_type"])
+
+    where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
+
+    # Total count query
+    count_query = f"SELECT COUNT(*) as total FROM drivers{where_sql}"
+
+    # Breakdown by status query
+    status_query = f"""
+        SELECT status, COUNT(*) as count
+        FROM drivers{where_sql}
+        GROUP BY status
+        ORDER BY count DESC
+    """
+
+    # Breakdown by vehicle type query
+    vehicle_query = f"""
+        SELECT vehicle_type, COUNT(*) as count
+        FROM drivers{where_sql}
+        GROUP BY vehicle_type
+        ORDER BY count DESC
+    """
+
+    try:
+        # Execute queries
+        total_result = execute_query(count_query, tuple(params) if params else None)
+        total = total_result[0]['total'] if total_result else 0
+
+        status_result = execute_query(status_query, tuple(params) if params else None)
+        vehicle_result = execute_query(vehicle_query, tuple(params) if params else None)
+
+        # Format breakdown
+        status_breakdown = {row['status']: row['count'] for row in status_result} if status_result else {}
+        vehicle_breakdown = {row['vehicle_type']: row['count'] for row in vehicle_result if row['vehicle_type']} if vehicle_result else {}
+
+        logger.info(f"Counted drivers: {total} total")
+
+        return {
+            "success": True,
+            "total": total,
+            "status_breakdown": status_breakdown,
+            "vehicle_breakdown": vehicle_breakdown,
+            "message": f"Found {total} driver(s)"
+        }
+    except Exception as e:
+        logger.error(f"Database error counting drivers: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to count drivers: {str(e)}"
+        }
+
+
+def handle_fetch_drivers(tool_input: dict) -> dict:
+    """
+    Execute fetch drivers tool
+
+    Args:
+        tool_input: Dict with filter, pagination, and sorting options
+
+    Returns:
+        List of drivers matching criteria
+    """
+    # Extract pagination and sorting
+    limit = min(tool_input.get("limit", 10), 100)  # Cap at 100
+    offset = tool_input.get("offset", 0)
+    sort_by = tool_input.get("sort_by", "name")
+    sort_order = tool_input.get("sort_order", "ASC")
+
+    # Build WHERE clause based on filters
+    where_clauses = []
+    params = []
+
+    if "status" in tool_input:
+        where_clauses.append("status = %s")
+        params.append(tool_input["status"])
+
+    if "vehicle_type" in tool_input:
+        where_clauses.append("vehicle_type = %s")
+        params.append(tool_input["vehicle_type"])
+
+    where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
+
+    # Build query
+    query = f"""
+        SELECT
+            driver_id, name, phone, email,
+            current_lat, current_lng, last_location_update,
+            status, vehicle_type, vehicle_plate,
+            capacity_kg, capacity_m3, skills,
+            created_at, updated_at
+        FROM drivers
+        {where_sql}
+        ORDER BY {sort_by} {sort_order}
+        LIMIT %s OFFSET %s
+    """
+
+    params.extend([limit, offset])
+
+    try:
+        results = execute_query(query, tuple(params))
+
+        if not results:
+            return {
+                "success": True,
+                "drivers": [],
+                "count": 0,
+                "message": "No drivers found matching criteria"
+            }
+
+        # Format drivers for readability
+        drivers = []
+        for row in results:
+            # Parse skills JSON if present
+            skills = []
+            if row['skills']:
+                try:
+                    import json
+                    skills = json.loads(row['skills']) if isinstance(row['skills'], str) else row['skills']
+                except:
+                    skills = []
+
+            driver = {
+                "driver_id": row['driver_id'],
+                "name": row['name'],
+                "contact": {
+                    "phone": row['phone'],
+                    "email": row['email']
+                },
+                "location": {
+                    "latitude": float(row['current_lat']) if row['current_lat'] else None,
+                    "longitude": float(row['current_lng']) if row['current_lng'] else None,
+                    "last_update": str(row['last_location_update']) if row['last_location_update'] else None
+                },
+                "status": row['status'],
+                "vehicle": {
+                    "type": row['vehicle_type'],
+                    "plate": row['vehicle_plate'],
+                    "capacity_kg": float(row['capacity_kg']) if row['capacity_kg'] else None,
+                    "capacity_m3": float(row['capacity_m3']) if row['capacity_m3'] else None
+                },
+                "skills": skills,
+                "timestamps": {
+                    "created_at": str(row['created_at']),
+                    "updated_at": str(row['updated_at']) if row['updated_at'] else None
+                }
+            }
+            drivers.append(driver)
+
+        logger.info(f"Fetched {len(drivers)} drivers")
+
+        return {
+            "success": True,
+            "drivers": drivers,
+            "count": len(drivers),
+            "message": f"Retrieved {len(drivers)} driver(s)"
+        }
+    except Exception as e:
+        logger.error(f"Database error fetching drivers: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to fetch drivers: {str(e)}"
+        }
+
+
+def handle_get_driver_details(tool_input: dict) -> dict:
+    """
+    Execute get driver details tool
+
+    Args:
+        tool_input: Dict with driver_id
+
+    Returns:
+        Complete driver details
+    """
+    driver_id = tool_input.get("driver_id")
+
+    if not driver_id:
+        return {
+            "success": False,
+            "error": "driver_id is required"
+        }
+
+    query = """
+        SELECT
+            driver_id, name, phone, email,
+            current_lat, current_lng, last_location_update,
+            status, vehicle_type, vehicle_plate,
+            capacity_kg, capacity_m3, skills,
+            created_at, updated_at
+        FROM drivers
+        WHERE driver_id = %s
+    """
+
+    try:
+        results = execute_query(query, (driver_id,))
+
+        if not results:
+            return {
+                "success": False,
+                "error": f"Driver {driver_id} not found"
+            }
+
+        row = results[0]
+
+        # Parse skills JSON if present
+        skills = []
+        if row['skills']:
+            try:
+                import json
+                skills = json.loads(row['skills']) if isinstance(row['skills'], str) else row['skills']
+            except:
+                skills = []
+
+        driver = {
+            "driver_id": row['driver_id'],
+            "name": row['name'],
+            "contact": {
+                "phone": row['phone'],
+                "email": row['email']
+            },
+            "location": {
+                "latitude": float(row['current_lat']) if row['current_lat'] else None,
+                "longitude": float(row['current_lng']) if row['current_lng'] else None,
+                "last_update": str(row['last_location_update']) if row['last_location_update'] else None
+            },
+            "status": row['status'],
+            "vehicle": {
+                "type": row['vehicle_type'],
+                "plate": row['vehicle_plate'],
+                "capacity_kg": float(row['capacity_kg']) if row['capacity_kg'] else None,
+                "capacity_m3": float(row['capacity_m3']) if row['capacity_m3'] else None
+            },
+            "skills": skills,
+            "timestamps": {
+                "created_at": str(row['created_at']),
+                "updated_at": str(row['updated_at']) if row['updated_at'] else None
+            }
+        }
+
+        logger.info(f"Retrieved details for driver: {driver_id}")
+
+        return {
+            "success": True,
+            "driver": driver,
+            "message": f"Driver {driver_id} details retrieved"
+        }
+    except Exception as e:
+        logger.error(f"Database error getting driver details: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to get driver details: {str(e)}"
+        }
+
+
+def handle_search_drivers(tool_input: dict) -> dict:
+    """
+    Execute search drivers tool
+
+    Args:
+        tool_input: Dict with search_term
+
+    Returns:
+        List of matching drivers
+    """
+    search_term = tool_input.get("search_term", "").strip()
+
+    if not search_term:
+        return {
+            "success": False,
+            "error": "search_term is required"
+        }
+
+    query = """
+        SELECT
+            driver_id, name, phone, email,
+            vehicle_type, vehicle_plate, status, created_at
+        FROM drivers
+        WHERE
+            driver_id ILIKE %s OR
+            name ILIKE %s OR
+            email ILIKE %s OR
+            phone ILIKE %s OR
+            vehicle_plate ILIKE %s
+        ORDER BY name ASC
+        LIMIT 50
+    """
+
+    search_pattern = f"%{search_term}%"
+    params = (search_pattern, search_pattern, search_pattern, search_pattern, search_pattern)
+
+    try:
+        results = execute_query(query, params)
+
+        if not results:
+            return {
+                "success": True,
+                "drivers": [],
+                "count": 0,
+                "message": f"No drivers found matching '{search_term}'"
+            }
+
+        drivers = []
+        for row in results:
+            drivers.append({
+                "driver_id": row['driver_id'],
+                "name": row['name'],
+                "phone": row['phone'],
+                "email": row['email'],
+                "vehicle_type": row['vehicle_type'],
+                "vehicle_plate": row['vehicle_plate'],
+                "status": row['status'],
+                "created_at": str(row['created_at'])
+            })
+
+        logger.info(f"Search '{search_term}' found {len(drivers)} drivers")
+
+        return {
+            "success": True,
+            "drivers": drivers,
+            "count": len(drivers),
+            "message": f"Found {len(drivers)} driver(s) matching '{search_term}'"
+        }
+    except Exception as e:
+        logger.error(f"Database error searching drivers: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to search drivers: {str(e)}"
+        }
+
+
+def handle_get_available_drivers(tool_input: dict) -> dict:
+    """
+    Execute get available drivers tool
+
+    Args:
+        tool_input: Dict with optional limit
+
+    Returns:
+        List of available drivers (active or offline)
+    """
+    limit = min(tool_input.get("limit", 20), 100)
+
+    query = """
+        SELECT
+            driver_id, name, phone, vehicle_type, vehicle_plate,
+            current_lat, current_lng, last_location_update,
+            status, capacity_kg, capacity_m3, skills
+        FROM drivers
+        WHERE status IN ('active', 'offline')
+        ORDER BY
+            CASE status
+                WHEN 'active' THEN 1
+                WHEN 'offline' THEN 2
+            END,
+            name ASC
+        LIMIT %s
+    """
+
+    try:
+        results = execute_query(query, (limit,))
+
+        if not results:
+            return {
+                "success": True,
+                "drivers": [],
+                "count": 0,
+                "message": "No available drivers found"
+            }
+
+        drivers = []
+        for row in results:
+            # Parse skills JSON if present
+            skills = []
+            if row['skills']:
+                try:
+                    import json
+                    skills = json.loads(row['skills']) if isinstance(row['skills'], str) else row['skills']
+                except:
+                    skills = []
+
+            drivers.append({
+                "driver_id": row['driver_id'],
+                "name": row['name'],
+                "phone": row['phone'],
+                "location": {
+                    "latitude": float(row['current_lat']) if row['current_lat'] else None,
+                    "longitude": float(row['current_lng']) if row['current_lng'] else None,
+                    "last_update": str(row['last_location_update']) if row['last_location_update'] else None
+                },
+                "status": row['status'],
+                "vehicle": {
+                    "type": row['vehicle_type'],
+                    "plate": row['vehicle_plate'],
+                    "capacity_kg": float(row['capacity_kg']) if row['capacity_kg'] else None,
+                    "capacity_m3": float(row['capacity_m3']) if row['capacity_m3'] else None
+                },
+                "skills": skills
+            })
+
+        logger.info(f"Retrieved {len(drivers)} available drivers")
+
+        return {
+            "success": True,
+            "drivers": drivers,
+            "count": len(drivers),
+            "message": f"Found {len(drivers)} available driver(s)"
+        }
+    except Exception as e:
+        logger.error(f"Database error getting available drivers: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to get available drivers: {str(e)}"
+        }
+
+
 def get_tools_list() -> list:
     """Get list of available tools"""
     return [tool["name"] for tool in TOOLS_SCHEMA]