Add order and driver management tools with update and delete functionalities

chat/providers/gemini_provider.py

@@ -83,6 +83,10 @@ You: [geocode_address] → "OK geocoded, now creating..." ❌ WRONG!
 - 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
@@ -93,6 +97,10 @@ You: [geocode_address] → "OK geocoded, now creating..." ❌ WRONG!
 **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
@@ -532,6 +540,75 @@ You: [get_driver_details with driver_id=DRV-20251114163800] → [Display complet
                             },
                             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"]
+                        )
                     )
                 ]
             )

chat/tools.py

@@ -375,6 +375,171 @@ TOOLS_SCHEMA = [
             },
             "required": []
         }
+    },
+    {
+        "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.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "order_id": {
+                    "type": "string",
+                    "description": "Order ID to update (e.g., 'ORD-20250114123456')"
+                },
+                "customer_name": {
+                    "type": "string",
+                    "description": "Updated customer name"
+                },
+                "customer_phone": {
+                    "type": "string",
+                    "description": "Updated customer phone number"
+                },
+                "customer_email": {
+                    "type": "string",
+                    "description": "Updated customer email address"
+                },
+                "delivery_address": {
+                    "type": "string",
+                    "description": "Updated delivery address"
+                },
+                "delivery_lat": {
+                    "type": "number",
+                    "description": "Updated delivery latitude (required if updating address)"
+                },
+                "delivery_lng": {
+                    "type": "number",
+                    "description": "Updated delivery longitude (required if updating address)"
+                },
+                "status": {
+                    "type": "string",
+                    "description": "Updated order status",
+                    "enum": ["pending", "assigned", "in_transit", "delivered", "failed", "cancelled"]
+                },
+                "priority": {
+                    "type": "string",
+                    "description": "Updated priority level",
+                    "enum": ["standard", "express", "urgent"]
+                },
+                "special_instructions": {
+                    "type": "string",
+                    "description": "Updated special delivery instructions"
+                },
+                "time_window_end": {
+                    "type": "string",
+                    "description": "Updated delivery deadline (ISO format datetime)"
+                },
+                "payment_status": {
+                    "type": "string",
+                    "description": "Updated payment status",
+                    "enum": ["pending", "paid", "cod"]
+                },
+                "weight_kg": {
+                    "type": "number",
+                    "description": "Updated package weight in kilograms"
+                },
+                "order_value": {
+                    "type": "number",
+                    "description": "Updated order value in currency"
+                }
+            },
+            "required": ["order_id"]
+        }
+    },
+    {
+        "name": "delete_order",
+        "description": "Permanently delete an order from the database. This action cannot be undone. Use with caution.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "order_id": {
+                    "type": "string",
+                    "description": "Order ID to delete (e.g., 'ORD-20250114123456')"
+                },
+                "confirm": {
+                    "type": "boolean",
+                    "description": "Must be set to true to confirm deletion"
+                }
+            },
+            "required": ["order_id", "confirm"]
+        }
+    },
+    {
+        "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.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "driver_id": {
+                    "type": "string",
+                    "description": "Driver ID to update (e.g., 'DRV-20250114123456')"
+                },
+                "name": {
+                    "type": "string",
+                    "description": "Updated driver name"
+                },
+                "phone": {
+                    "type": "string",
+                    "description": "Updated phone number"
+                },
+                "email": {
+                    "type": "string",
+                    "description": "Updated email address"
+                },
+                "status": {
+                    "type": "string",
+                    "description": "Updated driver status",
+                    "enum": ["active", "busy", "offline", "unavailable"]
+                },
+                "vehicle_type": {
+                    "type": "string",
+                    "description": "Updated vehicle type"
+                },
+                "vehicle_plate": {
+                    "type": "string",
+                    "description": "Updated vehicle license plate"
+                },
+                "capacity_kg": {
+                    "type": "number",
+                    "description": "Updated cargo capacity in kilograms"
+                },
+                "capacity_m3": {
+                    "type": "number",
+                    "description": "Updated cargo capacity in cubic meters"
+                },
+                "skills": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Updated list of driver skills/certifications"
+                },
+                "current_lat": {
+                    "type": "number",
+                    "description": "Updated current latitude"
+                },
+                "current_lng": {
+                    "type": "number",
+                    "description": "Updated current longitude"
+                }
+            },
+            "required": ["driver_id"]
+        }
+    },
+    {
+        "name": "delete_driver",
+        "description": "Permanently delete a driver from the database. This action cannot be undone. Use with caution.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "driver_id": {
+                    "type": "string",
+                    "description": "Driver ID to delete (e.g., 'DRV-20250114123456')"
+                },
+                "confirm": {
+                    "type": "boolean",
+                    "description": "Must be set to true to confirm deletion"
+                }
+            },
+            "required": ["driver_id", "confirm"]
+        }
     }
 ]
 
@@ -417,6 +582,14 @@ def execute_tool(tool_name: str, tool_input: dict) -> dict:
             return handle_search_drivers(tool_input)
         elif tool_name == "get_available_drivers":
             return handle_get_available_drivers(tool_input)
+        elif tool_name == "update_order":
+            return handle_update_order(tool_input)
+        elif tool_name == "delete_order":
+            return handle_delete_order(tool_input)
+        elif tool_name == "update_driver":
+            return handle_update_driver(tool_input)
+        elif tool_name == "delete_driver":
+            return handle_delete_driver(tool_input)
         else:
             return {
                 "success": False,
@@ -647,6 +820,335 @@ def handle_create_driver(tool_input: dict) -> dict:
         }
 
 
+def handle_update_order(tool_input: dict) -> dict:
+    """
+    Execute order update tool
+
+    Args:
+        tool_input: Dict with order_id and fields to update
+
+    Returns:
+        Update result
+    """
+    import json
+
+    order_id = tool_input.get("order_id")
+
+    # Validate required field
+    if not order_id:
+        return {
+            "success": False,
+            "error": "Missing required field: order_id"
+        }
+
+    # Check if order exists
+    check_query = "SELECT order_id FROM orders WHERE order_id = %s"
+    existing = execute_query(check_query, (order_id,))
+
+    if not existing:
+        return {
+            "success": False,
+            "error": f"Order {order_id} not found"
+        }
+
+    # Auto-geocode if delivery address is updated without coordinates
+    if "delivery_address" in tool_input and ("delivery_lat" not in tool_input or "delivery_lng" not in tool_input):
+        from chat.geocoding import GeocodingService
+        geocoding_service = GeocodingService()
+
+        try:
+            geocode_result = geocoding_service.geocode(tool_input["delivery_address"])
+            tool_input["delivery_lat"] = geocode_result["lat"]
+            tool_input["delivery_lng"] = geocode_result["lng"]
+            logger.info(f"Auto-geocoded delivery address: {geocode_result['formatted_address']}")
+        except Exception as e:
+            logger.warning(f"Failed to geocode address, skipping coordinate update: {e}")
+
+    # Build UPDATE query dynamically based on provided fields
+    update_fields = []
+    params = []
+
+    # Map of field names to their database columns
+    updateable_fields = {
+        "customer_name": "customer_name",
+        "customer_phone": "customer_phone",
+        "customer_email": "customer_email",
+        "delivery_address": "delivery_address",
+        "delivery_lat": "delivery_lat",
+        "delivery_lng": "delivery_lng",
+        "status": "status",
+        "priority": "priority",
+        "special_instructions": "special_instructions",
+        "time_window_end": "time_window_end",
+        "payment_status": "payment_status",
+        "weight_kg": "weight_kg",
+        "order_value": "order_value"
+    }
+
+    for field, column in updateable_fields.items():
+        if field in tool_input:
+            update_fields.append(f"{column} = %s")
+            params.append(tool_input[field])
+
+    if not update_fields:
+        return {
+            "success": False,
+            "error": "No fields provided to update"
+        }
+
+    # Always update the updated_at timestamp
+    update_fields.append("updated_at = %s")
+    params.append(datetime.now())
+
+    # Add order_id for WHERE clause
+    params.append(order_id)
+
+    # Execute update
+    query = f"""
+        UPDATE orders
+        SET {', '.join(update_fields)}
+        WHERE order_id = %s
+    """
+
+    try:
+        execute_write(query, tuple(params))
+        logger.info(f"Order updated: {order_id}")
+
+        return {
+            "success": True,
+            "order_id": order_id,
+            "updated_fields": list(updateable_fields.keys() & tool_input.keys()),
+            "message": f"Order {order_id} updated successfully!"
+        }
+    except Exception as e:
+        logger.error(f"Database error updating order: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to update order: {str(e)}"
+        }
+
+
+def handle_delete_order(tool_input: dict) -> dict:
+    """
+    Execute order deletion tool
+
+    Args:
+        tool_input: Dict with order_id and confirm flag
+
+    Returns:
+        Deletion result
+    """
+    order_id = tool_input.get("order_id")
+    confirm = tool_input.get("confirm", False)
+
+    # Validate required fields
+    if not order_id:
+        return {
+            "success": False,
+            "error": "Missing required field: order_id"
+        }
+
+    if not confirm:
+        return {
+            "success": False,
+            "error": "Deletion not confirmed. Set confirm=true to proceed."
+        }
+
+    # Check if order exists
+    check_query = "SELECT order_id, status FROM orders WHERE order_id = %s"
+    existing = execute_query(check_query, (order_id,))
+
+    if not existing:
+        return {
+            "success": False,
+            "error": f"Order {order_id} not found"
+        }
+
+    # Delete the order
+    query = "DELETE FROM orders WHERE order_id = %s"
+
+    try:
+        execute_write(query, (order_id,))
+        logger.info(f"Order deleted: {order_id}")
+
+        return {
+            "success": True,
+            "order_id": order_id,
+            "message": f"Order {order_id} has been permanently deleted."
+        }
+    except Exception as e:
+        logger.error(f"Database error deleting order: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to delete order: {str(e)}"
+        }
+
+
+def handle_update_driver(tool_input: dict) -> dict:
+    """
+    Execute driver update tool
+
+    Args:
+        tool_input: Dict with driver_id and fields to update
+
+    Returns:
+        Update result
+    """
+    import json
+
+    driver_id = tool_input.get("driver_id")
+
+    # Validate required field
+    if not driver_id:
+        return {
+            "success": False,
+            "error": "Missing required field: driver_id"
+        }
+
+    # Check if driver exists
+    check_query = "SELECT driver_id FROM drivers WHERE driver_id = %s"
+    existing = execute_query(check_query, (driver_id,))
+
+    if not existing:
+        return {
+            "success": False,
+            "error": f"Driver {driver_id} not found"
+        }
+
+    # Build UPDATE query dynamically based on provided fields
+    update_fields = []
+    params = []
+
+    # Map of field names to their database columns
+    updateable_fields = {
+        "name": "name",
+        "phone": "phone",
+        "email": "email",
+        "status": "status",
+        "vehicle_type": "vehicle_type",
+        "vehicle_plate": "vehicle_plate",
+        "capacity_kg": "capacity_kg",
+        "capacity_m3": "capacity_m3",
+        "current_lat": "current_lat",
+        "current_lng": "current_lng"
+    }
+
+    for field, column in updateable_fields.items():
+        if field in tool_input:
+            update_fields.append(f"{column} = %s")
+            params.append(tool_input[field])
+
+    # Handle skills array specially (convert to JSON)
+    if "skills" in tool_input:
+        skills = list(tool_input.get("skills", []))
+        update_fields.append("skills = %s")
+        params.append(json.dumps(skills))
+
+    if not update_fields:
+        return {
+            "success": False,
+            "error": "No fields provided to update"
+        }
+
+    # Always update the updated_at timestamp
+    update_fields.append("updated_at = %s")
+    params.append(datetime.now())
+
+    # Update location timestamp if lat/lng changed
+    if "current_lat" in tool_input or "current_lng" in tool_input:
+        update_fields.append("last_location_update = %s")
+        params.append(datetime.now())
+
+    # Add driver_id for WHERE clause
+    params.append(driver_id)
+
+    # Execute update
+    query = f"""
+        UPDATE drivers
+        SET {', '.join(update_fields)}
+        WHERE driver_id = %s
+    """
+
+    try:
+        execute_write(query, tuple(params))
+        logger.info(f"Driver updated: {driver_id}")
+
+        updated_list = list(updateable_fields.keys() & tool_input.keys())
+        if "skills" in tool_input:
+            updated_list.append("skills")
+
+        return {
+            "success": True,
+            "driver_id": driver_id,
+            "updated_fields": updated_list,
+            "message": f"Driver {driver_id} updated successfully!"
+        }
+    except Exception as e:
+        logger.error(f"Database error updating driver: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to update driver: {str(e)}"
+        }
+
+
+def handle_delete_driver(tool_input: dict) -> dict:
+    """
+    Execute driver deletion tool
+
+    Args:
+        tool_input: Dict with driver_id and confirm flag
+
+    Returns:
+        Deletion result
+    """
+    driver_id = tool_input.get("driver_id")
+    confirm = tool_input.get("confirm", False)
+
+    # Validate required fields
+    if not driver_id:
+        return {
+            "success": False,
+            "error": "Missing required field: driver_id"
+        }
+
+    if not confirm:
+        return {
+            "success": False,
+            "error": "Deletion not confirmed. Set confirm=true to proceed."
+        }
+
+    # Check if driver exists
+    check_query = "SELECT driver_id, name FROM drivers WHERE driver_id = %s"
+    existing = execute_query(check_query, (driver_id,))
+
+    if not existing:
+        return {
+            "success": False,
+            "error": f"Driver {driver_id} not found"
+        }
+
+    driver_name = existing[0]["name"]
+
+    # Delete the driver
+    query = "DELETE FROM drivers WHERE driver_id = %s"
+
+    try:
+        execute_write(query, (driver_id,))
+        logger.info(f"Driver deleted: {driver_id}")
+
+        return {
+            "success": True,
+            "driver_id": driver_id,
+            "message": f"Driver {driver_id} ({driver_name}) has been permanently deleted."
+        }
+    except Exception as e:
+        logger.error(f"Database error deleting driver: {e}")
+        return {
+            "success": False,
+            "error": f"Failed to delete driver: {str(e)}"
+        }
+
+
 def handle_count_orders(tool_input: dict) -> dict:
     """
     Execute count orders tool

ui/app.py

@@ -351,6 +351,66 @@ def get_driver_details(driver_id):
         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
 # ============================================
@@ -443,12 +503,21 @@ def create_interface():
 
                 # 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",
@@ -515,6 +584,26 @@ def create_interface():
                     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],
@@ -603,6 +692,42 @@ def create_interface():
                 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)
@@ -643,6 +768,93 @@ def create_interface():
                     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
             # ==========================================
@@ -707,6 +919,38 @@ def create_interface():
                 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)
@@ -747,6 +991,96 @@ def create_interface():
                     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*")