diff --git a/Chat/index.html b/Chat/index.html
index 8c5c5dbf..0c3b68e0 100644
--- a/Chat/index.html
+++ b/Chat/index.html
@@ -106,6 +106,12 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
       <button id="mavlink-arm-button">Arm</button>
   </div>
 
+  <!-- MAVLink guided mode button -->
+    <div class="mavlink-guided-container">
+        <label for="mavlink-guided-vehicle">Guided Mode</label>
+        <button id="mavlink-guided-button">Guided</button>
+    </div>
+
   <!-- debug output text box -->
   <div class="debug-output-container">
       <textarea id="debugOutput" class="input-field" rows="10" readonly></textarea>
@@ -125,10 +131,14 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
     // MAVLink connection related functions
     let connect_button = document.getElementById("mavlink-connect-button");
     let is_connected = false; // connection state
-    let mavlink_ws = null; // websocket object
+    // let mavlink_ws = null; // websocket object
+    
     let mavlink_sysid = 254; // system id
     let mavlink_compid = MAVLink20Processor.MAV_COMP_ID_MISSIONPLANNER; // component id
-    let MAVLink = new MAVLink20Processor(null, mavlink_sysid, mavlink_compid);
+    // let MAVLink = new MAVLink20Processor(null, mavlink_sysid, mavlink_compid);
+    
+    window.mavlink_ws = null; // Make them globally accessible
+    window.MAVLink = new MAVLink20Processor(null, mavlink_sysid, mavlink_compid);
 
     // toggle connection state (called by Connect/Disconnect button)
     function mavlink_toggle_connect() {
@@ -281,12 +291,115 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
     // attach event listener to the arm button
     document.getElementById("mavlink-arm-button").addEventListener("click", mavlink_arm_vehicle);
 
+
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // switch to guided mode
+function mavlink_switch_to_guided() {
+    if (mavlink_ws == null || mavlink_ws.readyState !== WebSocket.OPEN) {
+        alert("Please connect to the vehicle first");
+        return;
+    }
+    
+    // Use command_long message for mode change (command 176: MAV_CMD_DO_SET_MODE)
+    let command_long_msg = new mavlink20.messages.command_long(
+        1,    // Target system ID
+        1,    // Target component ID
+        176,  // MAV_CMD_DO_SET_MODE
+        1,    // Confirmation
+        1,    // Param1: set to 1 for MAV_MODE_FLAG_CUSTOM_MODE_ENABLED
+        4,    // Param2: 4 is GUIDED mode for Copter
+        0, 0, 0, 0, 0    // Unused parameters
+    );
+
+    const buffer = MAVLink.send(command_long_msg);
+    const uint = new Uint8Array(buffer);
+
+    // send the message as an ArrayBuffer over the WebSocket
+    if (mavlink_ws && mavlink_ws.readyState === WebSocket.OPEN) {
+        mavlink_ws.send(uint);
+        add_text_to_debug("Sent GUIDED mode command via MAVLink");
+    } else {
+        alert("WebSocket is not open. Cannot send GUIDED mode command.");
+    }
+}
+// attach event listener to the guided mode button
+document.getElementById("mavlink-guided-button").addEventListener("click", mavlink_switch_to_guided);
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
     // add text to debug text box
     function add_text_to_debug(text) {
         let debugOutput = document.getElementById("debugOutput");
         debugOutput.value += text + "\n";
         debugOutput.scrollTop = debugOutput.scrollHeight;
     }
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Global variable to store wakeup timers
+    const wakeup_timers = [];
+
+    // Then implement set_wakeup_timer
+    function set_wakeup_timer(args) {
+        // Parse arguments if needed
+        if (typeof args === 'string') {
+            try {
+                args = JSON.parse(args);
+            } catch (e) {
+                return "Error: Invalid arguments format";
+            }
+        }
+        
+        // Check required arguments
+        const seconds = args?.seconds;
+        if (seconds === undefined || seconds < 0) {
+            return "Error: seconds not specified or invalid";
+        }
+        
+        const message = args?.message;
+        if (!message) {
+            return "Error: message not specified";
+        }
+        
+        // Create a unique ID for the timer
+        const timer_id = Date.now().toString() + Math.random().toString(36).substr(2, 5);
+        
+        // Calculate expiry time
+        const expiry_time = new Date(Date.now() + seconds * 1000);
+        
+        // Create timer object
+        const timer = {
+            id: timer_id,
+            seconds: seconds,
+            message: message,
+            created_time: new Date(),
+            expiry_time: expiry_time
+        };
+        
+        // Add to wakeup schedule
+        wakeup_timers.push(timer);
+        
+        // Set the JavaScript timeout
+        setTimeout(() => {
+            // Add message to chat
+            const chatBox = document.getElementById("chatBox");
+            const messageDiv = document.createElement("div");
+            messageDiv.className = "user-text";
+            messageDiv.textContent = "WAKEUP:" + message;
+            chatBox.appendChild(messageDiv);
+            chatBox.scrollTop = chatBox.scrollHeight;
+            
+            add_text_to_debug("Wakeup timer triggered: " + message);
+            
+            // Remove from wakeup schedule
+            const index = wakeup_timers.findIndex(t => t.id === timer_id);
+            if (index !== -1) {
+                wakeup_timers.splice(index, 1);
+            }
+        }, seconds * 1000);
+        
+        return "Wakeup timer set for " + seconds + " seconds from now with message: " + message;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 </script>
 
 <script type="module">
@@ -512,37 +625,38 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
               return get_vehicle_type();
           case "get_parameter":
               // Get a vehicle parameter's value.  The full list of available parameters and their values is available using the get_all_parameters function
-              // fallthrough
+              return get_parameter(args);
           case "get_wakeup_timers":
               // Retrieves a list of all active wakeup timers. You can optionally provide a message parameter to filter timers by their associated messages. When specifying the message parameter, you can use regular expressions (regex) to match patterns within the timer messages. This is useful when you want to find timers with specific keywords or patterns in their messages. For example, to retrieve all timers containing the word 'hello', you can use the regex '.*hello.*', where the dot-star (.*) pattern matches any character sequence.
-              // fallthrough
+              return get_wakeup_timers(args);
           case "get_vehicle_location_and_yaw":
               // Get the vehicle's current location including latitude, longitude, altitude above sea level and altitude above home
-              // fallthrough
+              return get_vehicle_location_and_yaw();
           case "send_mavlink_set_position_target_global_int":
               // Send a mavlink SET_POSITION_TARGET_GLOBAL_INT message to the vehicle.  This message is the preferred way to command a vehicle to fly to a specified location or to fly at a specfied velocity
               // fallthrough
           case "get_vehicle_state":
               // Get the vehicle state including armed status and (flight) mode
-              // fallthrough
+              return get_vehicle_state();
           case "get_location_plus_offset":
               // Calculate the latitude and longitude given an existing latitude and longitude and distances (in meters) North and East
-              // fallthrough
+              return get_location_plus_offset(args);
+
           case "send_mavlink_command_int":
               // Send a mavlink COMMAND_INT message to the vehicle.  Available commands including changing the flight mode, arming, disarming, takeoff and commanding the vehicle to fly to a specific location
-              // fallthrough
+              return send_mavlink_command_int(args);
           case "get_location_plus_dist_at_bearing":
               // Calculate the latitude and longitude given an existing latitude and longitude and a distance in meters and a bearing in degrees
-              // fallthrough
+              return get_location_plus_dist_at_bearing(args);
           case "get_parameter_description":
               // Get vehicle parameter descriptions including description, units, min and max
-              // fallthrough
+              return get_parameter_description()
           case "delete_wakeup_timers":
               // Delete all active wakeup timers. You can optionally provide a message parameter to filter which timers will be deleted based on their message. When specifying the message parameter, you can use regular expressions (regex) to match patterns within the timer messages. This is useful when you want to delete timers with specific keywords or patterns in their message. For example, to delete all timers containing the word 'hello', you can use the regex '.*hello.*', where the dot-star (.*) pattern matches any character sequence.
               // fallthrough
           case "set_parameter":
               // Set a vehicle parameter's value.  The full list of parameters is available using the get_all_parameters function
-              // fallthrough
+              return set_parameter(args);
           case "get_mavlink_message":
               // Get a mavlink message including all fields and values sent by the vehicle.  The list of available messages can be retrieved using the get_available_mavlink_messages
               add_text_to_debug("Unknown function: " + name);
@@ -552,10 +666,10 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
               return getFormattedDate();
           case "get_mode_mapping":
               // Get a list of mode names to mode numbers available for this vehicle.  If the name or number parameter is provided only that mode's name and number will be returned.  If neither name nor number is provided the full list of available modes will be returned
-              // fallthrough
+              return get_mode_mapping(args);
           case "get_all_parameters":
               // Get all available parameter names and values
-              // fallthrough
+              return get_all_parameters();
           case "set_wakeup_timer":
               // Set a timer to wake you up in a specified number of seconds in the future.  This allows taking actions in the future.  The wakeup message will appear with the user role but will look something like WAKEUP:<message>.  Multiple wakeup messages are supported
               add_text_to_debug("Unknown function: " + name);
@@ -641,6 +755,894 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
       return new Date().toLocaleString('en-US', options);
   }
 
+
+    //get vehicle state
+    function get_vehicle_state(){
+        //get latest HEARTBEAT message
+        const heartbeat_msg = mavlink_store.get_latest_message(0);
+        //sanity check
+        if (!heartbeat_msg || !heartbeat_msg.hasOwnProperty("base_mode") || !heartbeat_msg.hasOwnProperty("custom_mode")) {
+            return "unknown because no HEARTBEAT message has been received from the vehicle";
+        }
+        //get the armed state flag by applying mask to base_model property
+        const armed_flag = (heartbeat_msg["base_mode"] & mavlink20.MAV_MODE_FLAG_SAFETY_ARMED) > 0;
+        //get mode number from custom_mode property
+        const mode_number = heartbeat_msg["custom_mode"];
+        
+        return {
+            "armed": armed_flag,
+            "mode": mode_number
+        }
+    }
+
+    function get_mode_mapping(args) {
+    // Parse arguments if needed
+    if (typeof args === 'string') {
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            return JSON.stringify({ error: "Invalid arguments format" });
+        }
+    }
+    
+    // Get mode_name and mode_number from arguments
+    const mode_name = args?.name ? args.name.toUpperCase() : undefined;
+    const mode_number = args?.number !== undefined ? parseInt(args.number) : undefined;
+    
+    // Get vehicle type to determine which mode mapping to use
+    const vehicle_type = get_vehicle_type();
+    
+    // Define mode mappings for different vehicle types
+    const mode_mappings = {
+        "Copter": {
+            "STABILIZE": 0,
+            "ACRO": 1,
+            "ALT_HOLD": 2,
+            "AUTO": 3,
+            "GUIDED": 4,
+            "LOITER": 5,
+            "RTL": 6,
+            "CIRCLE": 7,
+            "POSITION": 8,
+            "LAND": 9,
+            "DRIFT": 11,
+            "SPORT": 13,
+            "FLIP": 14,
+            "AUTOTUNE": 15,
+            "POSHOLD": 16,
+            "BRAKE": 17,
+            "THROW": 18,
+            "AVOID_ADSB": 19,
+            "GUIDED_NOGPS": 20,
+            "SMART_RTL": 21
+        },
+        "Plane": {
+            "MANUAL": 0,
+            "CIRCLE": 1,
+            "STABILIZE": 2,
+            "TRAINING": 3,
+            "ACRO": 4,
+            "FBWA": 5,
+            "FBWB": 6,
+            "CRUISE": 7,
+            "AUTOTUNE": 8,
+            "AUTO": 10,
+            "RTL": 11,
+            "LOITER": 12,
+            "TAKEOFF": 13,
+            "QSTABILIZE": 17,
+            "QHOVER": 18,
+            "QLOITER": 19,
+            "QLAND": 20,
+            "QRTL": 21
+        },
+        "Rover": {
+            "MANUAL": 0,
+            "ACRO": 1,
+            "STEERING": 3,
+            "HOLD": 4,
+            "LOITER": 5,
+            "AUTO": 10,
+            "RTL": 11,
+            "SMART_RTL": 12,
+            "GUIDED": 15
+        }
+    };
+    
+    // Get modes for the current vehicle type
+    const modes = mode_mappings[vehicle_type] || {};
+    
+    // Create result array
+    let mode_list = [];
+    
+    // Handle request based on provided arguments
+    if (mode_name === undefined && mode_number === undefined) {
+        // Return all modes
+        for (const [name, number] of Object.entries(modes)) {
+            mode_list.push({ name, number });
+        }
+    } else if (mode_name !== undefined) {
+        // Find mode by name
+        for (const [name, number] of Object.entries(modes)) {
+            if (name === mode_name) {
+                mode_list.push({ name, number });
+                break;
+            }
+        }
+    } else if (mode_number !== undefined) {
+        // Find mode by number
+        for (const [name, number] of Object.entries(modes)) {
+            if (number === mode_number) {
+                mode_list.push({ name, number });
+                break;
+            }
+        }
+    }
+    
+    return JSON.stringify(mode_list);
+}
+
+function get_all_parameters() {
+    // Check if any parameters are available
+    const param_message = mavlink_store.get_latest_message(22); // 22 is PARAM_VALUE
+    if (!param_message) {
+        return JSON.stringify({
+            error: "No parameters available. Parameters haven't been received from the vehicle yet."
+        });
+    }
+    
+    // We need to collect all parameters from the store
+    let param_list = {};
+    
+    // MAVLink store organizes by system_id, component_id, and message_id
+    const systems = Object.keys(mavlink_store.store);
+    for (const sysid of systems) {
+        const components = Object.keys(mavlink_store.store[sysid]);
+        for (const compid of components) {
+            // Check if this system/component has parameter messages
+            if (mavlink_store.store[sysid][compid] && 
+                mavlink_store.store[sysid][compid][22]) { // 22 = PARAM_VALUE
+                
+                // Parameters are stored individually - we'll need to collect them all
+                const messages = mavlink_store.store[sysid][compid][22];
+                
+                // Handle single messages and arrays of messages
+                if (Array.isArray(messages)) {
+                    for (const msg of messages) {
+                        if (msg.param_id) {
+                            param_list[msg.param_id] = msg.param_value;
+                        }
+                    }
+                } else if (messages.param_id) {
+                    // Single message
+                    param_list[messages.param_id] = messages.param_value;
+                }
+            }
+        }
+    }
+    
+    // If no parameters found after checking
+    if (Object.keys(param_list).length === 0) {
+        return JSON.stringify({
+            error: "No parameter data found in MAVLink store"
+        });
+    }
+    
+    // Return parameters as JSON string
+    return JSON.stringify(param_list);
+}
+
+function get_parameter(args) {
+    // Parse arguments if needed
+    if (typeof args === 'string') {
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            return JSON.stringify({ error: "Invalid arguments format" });
+        }
+    }
+    
+    // Get parameter name
+    const param_name = args?.name;
+    if (!param_name) {
+        return JSON.stringify({ error: "get_parameter: name not specified" });
+    }
+    
+    // Start with empty parameter list
+    let param_list = {};
+    
+    // Check if parameter name contains regex
+    const contains_regex = /[.*+?^${}()|[\]\\]/.test(param_name);
+    
+    if (contains_regex) {
+        try {
+            // Create regex pattern
+            const pattern = new RegExp(param_name);
+            
+            // Get all parameters
+            const all_params_str = get_all_parameters();
+            let all_params;
+            try {
+                all_params = JSON.parse(all_params_str);
+            } catch (e) {
+                return JSON.stringify({ error: "Failed to parse parameters" });
+            }
+            
+            // If there was an error getting parameters
+            if (all_params.error) {
+                return JSON.stringify({ error: all_params.error });
+            }
+            
+            // Find matching parameters
+            for (const [existing_param_name, param_value] of Object.entries(all_params)) {
+                if (pattern.test(existing_param_name)) {
+                    param_list[existing_param_name] = param_value;
+                }
+            }
+            
+            // Return error if no matches found
+            if (Object.keys(param_list).length === 0) {
+                return JSON.stringify({ error: "No parameters match pattern: " + param_name });
+            }
+        } catch (e) {
+            return JSON.stringify({ error: "Invalid regex pattern: " + e.message });
+        }
+    } else {
+        // Handle simple case of a single parameter name
+        // Get the parameter message (ID 22 is PARAM_VALUE)
+        const systems = Object.keys(mavlink_store.store);
+        let param_found = false;
+        
+        // Search through all systems and components
+        for (const sysid of systems) {
+            const components = Object.keys(mavlink_store.store[sysid]);
+            for (const compid of components) {
+                if (mavlink_store.store[sysid][compid][22]) {
+                    const messages = mavlink_store.store[sysid][compid][22];
+                    
+                    // Handle both single messages and arrays
+                    if (Array.isArray(messages)) {
+                        for (const msg of messages) {
+                            if (msg.param_id === param_name) {
+                                param_list[param_name] = msg.param_value;
+                                param_found = true;
+                                break;
+                            }
+                        }
+                    } else if (messages.param_id === param_name) {
+                        param_list[param_name] = messages.param_value;
+                        param_found = true;
+                    }
+                    
+                    if (param_found) break;
+                }
+            }
+            if (param_found) break;
+        }
+        
+        if (!param_found) {
+            return JSON.stringify({ error: "get_parameter: " + param_name + " parameter not found" });
+        }
+    }
+    
+    return JSON.stringify(param_list);
+}
+
+function get_parameter_description(args) {
+    // Parse arguments if needed
+    if (typeof args === 'string') {
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            return JSON.stringify({ error: "Invalid arguments format" });
+        }
+    }
+    
+    // Get parameter name
+    const param_name = args?.name;
+    if (!param_name) {
+        return JSON.stringify({ error: "get_parameter_description: name not specified" });
+    }
+    
+    // Start with empty parameter descriptions object
+    let param_descriptions = {};
+    
+    // Check if parameter name contains regex
+    const contains_regex = /[.*+?^${}()|[\]\\]/.test(param_name);
+    
+    // Get vehicle type to determine which parameter set to use
+    const vehicle_type = get_vehicle_type();
+    
+    if (contains_regex) {
+        try {
+            // Create regex pattern
+            const pattern = new RegExp(param_name);
+            
+            // Get all parameters to check against
+            const all_params_str = get_all_parameters();
+            let all_params;
+            try {
+                all_params = JSON.parse(all_params_str);
+            } catch (e) {
+                return JSON.stringify({ error: "Failed to parse parameters" });
+            }
+            
+            // If there was an error getting parameters
+            if (all_params.error) {
+                return JSON.stringify({ error: all_params.error });
+            }
+            
+            // Find matching parameters and get descriptions
+            for (const existing_param_name of Object.keys(all_params)) {
+                if (pattern.test(existing_param_name)) {
+                    const param_desc = get_single_parameter_description(vehicle_type, existing_param_name);
+                    if (param_desc) {
+                        param_descriptions[existing_param_name] = param_desc;
+                    }
+                }
+            }
+            
+            // Return error if no descriptions found
+            if (Object.keys(param_descriptions).length === 0) {
+                return JSON.stringify({ 
+                    error: "No parameter descriptions found matching pattern: " + param_name 
+                });
+            }
+        } catch (e) {
+            return JSON.stringify({ error: "Invalid regex pattern: " + e.message });
+        }
+    } else {
+        // Handle simple case of a single parameter name
+        const param_desc = get_single_parameter_description(vehicle_type, param_name);
+        if (!param_desc) {
+            return JSON.stringify({ 
+                error: "get_parameter_description: " + param_name + " parameter description not found" 
+            });
+        }
+        param_descriptions[param_name] = param_desc;
+    }
+    
+    return JSON.stringify(param_descriptions);
+}
+
+// Helper function to get description for a single parameter
+function get_single_parameter_description(vehicle_type, param_name) {
+    // Define common parameter descriptions with details like description, units, min, max and values
+    const common_parameters = {
+        "ACRO_BAL_PITCH": {
+            description: "ACRO Mode Balance Parameter for Pitch axis",
+            units: "None",
+            min: 0,
+            max: 3,
+            values: null
+        },
+        "ACRO_BAL_ROLL": {
+            description: "ACRO Mode Balance Parameter for Roll axis",
+            units: "None",
+            min: 0,
+            max: 3,
+            values: null
+        },
+        "BATT_MONITOR": {
+            description: "Battery monitoring type",
+            units: "None",
+            min: 0,
+            max: 10,
+            values: {
+                "0": "Disabled",
+                "3": "Analog Voltage Only",
+                "4": "Analog Voltage and Current",
+                "5": "Solo"
+            }
+        },
+        "MOT_SPIN_ARM": {
+            description: "Motor spin when armed",
+            units: "%",
+            min: 0,
+            max: 100,
+            values: null
+        },
+        "RTL_ALT": {
+            description: "Return-to-Launch altitude",
+            units: "cm",
+            min: 0,
+            max: 8000,
+            values: null
+        },
+        "PILOT_THR_FILT": {
+            description: "Throttle filter cutoff",
+            units: "Hz",
+            min: 0,
+            max: 10,
+            values: null
+        }
+    };
+    
+    // Vehicle-specific parameters
+    const vehicle_parameters = {
+        "Copter": {
+            "MOT_THST_HOVER": {
+                description: "Hover thrust coefficient",
+                units: "None",
+                min: 0.1,
+                max: 0.9,
+                values: null
+            },
+            "ATC_ANG_RLL_P": {
+                description: "Roll axis rate controller P gain",
+                units: "None",
+                min: 0,
+                max: 12,
+                values: null
+            }
+        },
+        "Plane": {
+            "TECS_CLMB_MAX": {
+                description: "Maximum climb rate",
+                units: "m/s",
+                min: 0,
+                max: 20,
+                values: null
+            },
+            "LIM_ROLL_CD": {
+                description: "Maximum bank angle",
+                units: "centidegrees",
+                min: 0,
+                max: 9000,
+                values: null
+            }
+        },
+        "Rover": {
+            "ATC_STR_RAT_FF": {
+                description: "Steering control rate feed forward",
+                units: "None",
+                min: 0,
+                max: 10,
+                values: null
+            },
+            "WP_RADIUS": {
+                description: "Waypoint radius",
+                units: "m",
+                min: 0,
+                max: 100,
+                values: null
+            }
+        }
+    };
+    
+    // First check vehicle-specific parameters
+    if (vehicle_parameters[vehicle_type] && vehicle_parameters[vehicle_type][param_name]) {
+        return vehicle_parameters[vehicle_type][param_name];
+    }
+    
+    // Then check common parameters
+    if (common_parameters[param_name]) {
+        return common_parameters[param_name];
+    }
+    
+    // For parameters not in our database, create a placeholder description
+    if (param_name) {
+        const parts = param_name.split('_');
+        return {
+            description: `${param_name} parameter`,
+            units: "Unknown",
+            min: 0,
+            max: 0,
+            values: null,
+            note: "Limited description available. This is a placeholder."
+        };
+    }
+    
+    return null;
+}
+
+function get_vehicle_location_and_yaw() {
+    // Get the latest GLOBAL_POSITION_INT message (ID 33)
+    const position_msg = mavlink_store.get_latest_message(33);
+    
+    // Sanity check that we have a position message
+    if (!position_msg) {
+        return JSON.stringify({
+            error: "No position data available. GLOBAL_POSITION_INT message hasn't been received yet."
+        });
+    }
+    
+    // Get the latest ATTITUDE message for yaw (if available)
+    const attitude_msg = mavlink_store.get_latest_message(30);
+    
+    // Convert lat/lon from int32 (degE7) to decimal degrees
+    const lat = position_msg.lat / 10000000.0;
+    const lon = position_msg.lon / 10000000.0;
+    
+    // Create the response object
+    const response = {
+        latitude: lat,
+        longitude: lon,
+        altitude_amsl: position_msg.alt / 1000.0,         // mm to meters
+        altitude_above_home: position_msg.relative_alt / 1000.0,  // mm to meters
+        heading: position_msg.hdg / 100.0                // centi-degrees to degrees
+    };
+    
+    // Add attitude information if available
+    if (attitude_msg) {
+        response.yaw = attitude_msg.yaw * (180 / Math.PI);  // radians to degrees
+    }
+    
+    return JSON.stringify(response);
+}
+
+// Helper function used by both location functions
+function get_latitude_longitude_given_offset(lat, lon, north_meters, east_meters) {
+    // Earth's radius in meters
+    const EARTH_RADIUS = 6378137.0;
+    
+    // Convert latitude and longitude from degrees to radians
+    const lat_rad = lat * (Math.PI / 180);
+    const lon_rad = lon * (Math.PI / 180);
+    
+    // Calculate new latitude
+    const new_lat_rad = lat_rad + north_meters / EARTH_RADIUS;
+    
+    // Calculate new longitude (accounting for latitude)
+    const new_lon_rad = lon_rad + east_meters / (EARTH_RADIUS * Math.cos(lat_rad));
+    
+    // Convert back to degrees
+    const new_lat = new_lat_rad * (180 / Math.PI);
+    const new_lon = new_lon_rad * (180 / Math.PI);
+    
+    return [new_lat, new_lon];
+}
+
+function get_location_plus_offset(args) {
+    // Parse arguments if needed
+    if (typeof args === 'string') {
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            return JSON.stringify({ error: "Invalid arguments format" });
+        }
+    }
+    
+    // Get parameters from args
+    const lat = args?.latitude || 0;
+    const lon = args?.longitude || 0;
+    const dist_north = args?.distance_north || 0;
+    const dist_east = args?.distance_east || 0;
+    
+    // Calculate new position
+    const [lat_with_offset, lon_with_offset] = get_latitude_longitude_given_offset(lat, lon, dist_north, dist_east);
+    
+    // Return result
+    return JSON.stringify({
+        latitude: lat_with_offset,
+        longitude: lon_with_offset
+    });
+}
+
+function get_location_plus_dist_at_bearing(args) {
+    // Parse arguments if needed
+    if (typeof args === 'string') {
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            return JSON.stringify({ error: "Invalid arguments format" });
+        }
+    }
+    
+    // Get parameters from args
+    const lat = args?.latitude || 0;
+    const lon = args?.longitude || 0;
+    const distance = args?.distance || 0;
+    const bearing_deg = args?.bearing || 0;
+    
+    // Convert bearing to north/east components
+    const bearing_rad = bearing_deg * (Math.PI / 180);
+    const dist_north = Math.cos(bearing_rad) * distance;
+    const dist_east = Math.sin(bearing_rad) * distance;
+    
+    // Calculate new position
+    const [lat_with_offset, lon_with_offset] = get_latitude_longitude_given_offset(lat, lon, dist_north, dist_east);
+    
+    // Return result
+    return JSON.stringify({
+        latitude: lat_with_offset,
+        longitude: lon_with_offset
+    });
+}
+
+function send_mavlink_command_int(args) {
+    // Parse arguments if needed
+    if (typeof args === 'string') {
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            add_text_to_debug("Error parsing args: " + e.message);
+            return "Error: Invalid arguments format";
+        }
+    }
+
+    // Check WebSocket connection
+    if (!window.mavlink_ws || window.mavlink_ws.readyState !== WebSocket.OPEN) {
+        add_text_to_debug("WebSocket not connected");
+        return "Error: WebSocket not connected";
+    }
+
+    // Extract arguments with defaults
+    const target_system = args.target_system || 1;
+    const target_component = args.target_component || 1;
+    const frame = args.frame || 0;
+    
+    if (!args.command) {
+        add_text_to_debug("Error: command field required");
+        return "Error: command field required";
+    }
+
+    // Convert parameters to proper numeric types
+    const command = Number(args.command);
+    const current = Number(args.current || 0);
+    const autocontinue = Number(args.autocontinue || 0);
+    const param1 = Number(args.param1 || 0);
+    const param2 = Number(args.param2 || 0);
+    const param3 = Number(args.param3 || 0);
+    const param4 = Number(args.param4 || 0);
+    const x = Number(args.x || 0);
+    const y = Number(args.y || 0);
+    const z = Number(args.z || 0);
+
+    try {
+        let mavlink_message;
+        
+        // Special handling for MAV_CMD_DO_SET_MODE (176)
+        if (command === 176) { // MAV_CMD_DO_SET_MODE
+            add_text_to_debug("Mode change detected, using COMMAND_LONG instead");
+
+            mavlink_message = new mavlink20.messages.command_long(
+                target_system,
+                target_component,
+                command,
+                1, // Confirmation
+                param1, // Base mode (MAV_MODE)
+                param2, // Custom mode
+                param3, // Sub-mode (if required)
+                0, 0, 0, 0 // Unused parameters
+            );
+
+            add_text_to_debug(`Sent mode change command: base_mode=${param1}, custom_mode=${param2}`);
+        } else {
+            // Default case: Send as COMMAND_INT
+            mavlink_message = new mavlink20.messages.command_int(
+                target_system,
+                target_component,
+                frame,
+                command,
+                current,
+                autocontinue,
+                param1,
+                param2,
+                param3,
+                param4,
+                x,
+                y,
+                z
+            );
+
+            add_text_to_debug(`Sent COMMAND_INT: cmd=${command}, x=${x}, y=${y}, z=${z}`);
+        }
+
+        // Send the message
+        // const buffer = MAVLink.send(mavlink_message);
+        const buffer = window.MAVLink.send(mavlink_message);
+        window.mavlink_ws.send(new Uint8Array(buffer));
+
+        return "Command sent successfully";
+    } catch (error) {
+        add_text_to_debug("Error sending command: " + error.message);
+        return "Error: " + error.message;
+    }
+}
+
+
+function set_parameter(args) {
+    // Parse arguments if they are a JSON string
+    if (typeof args === 'string') {
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            return JSON.stringify({ error: "Invalid arguments format: not valid JSON" });
+        }
+    }
+
+    // Extract required parameters
+    const param_name = args?.name;
+    const param_value = args?.value;
+
+    // Validate required parameters
+    if (!param_name) {
+        return JSON.stringify({ error: "set_parameter: Parameter name not specified" });
+    }
+
+    if (param_value === undefined) {
+        return JSON.stringify({ error: "set_parameter: Parameter value not specified" });
+    }
+
+    // Check WebSocket connection
+    if (!mavlink_ws || mavlink_ws.readyState !== WebSocket.OPEN) {
+        return JSON.stringify({ error: "WebSocket not connected. Please connect to vehicle first." });
+    }
+
+    try {
+        // Ensure the parameter name is exactly 16 characters (MAVLink limitation)
+        const param_name_fixed = param_name.padEnd(16, '\0').slice(0, 16);
+
+        // Determine the parameter type
+        let param_type;
+        let param_value_converted;
+
+        if (typeof param_value === 'number') {
+            if (Number.isInteger(param_value)) {
+                param_type = mavlink20.MAV_PARAM_TYPE_INT32;
+                param_value_converted = param_value;
+            } else {
+                param_type = mavlink20.MAV_PARAM_TYPE_REAL32;
+                param_value_converted = param_value;
+            }
+        } else if (typeof param_value === 'string') {
+            param_type = mavlink20.MAV_PARAM_TYPE_UINT8;
+            param_value_converted = param_value.charCodeAt(0);
+        } else {
+            return JSON.stringify({ error: "Unsupported parameter value type" });
+        }
+
+        // Create PARAM_SET message
+        let param_set_msg = new mavlink20.messages.param_set(
+            1,                  // Target system ID
+            1,                  // Target component ID
+            param_name_fixed,   // Fixed-length parameter name
+            param_value_converted, // Parameter value
+            param_type          // Parameter type
+        );
+
+        // Encode and send message via WebSocket
+        const buffer = MAVLink.send(param_set_msg);
+        const uint = new Uint8Array(buffer);
+        mavlink_ws.send(uint);
+
+        // Debug log
+        add_text_to_debug(`Sent PARAM_SET: ${param_name} = ${param_value}`);
+
+        return JSON.stringify({
+            result: "Parameter set command sent successfully",
+            details: {
+                name: param_name,
+                value: param_value
+            }
+        });
+    } catch (error) {
+        return JSON.stringify({ error: `Failed to set parameter: ${error.message}` });
+    }
+}
+
+
+
+// Global variable to store wakeup timers if not already defined
+// const wakeup_timers = wakeup_timers || [];
+
+// function set_wakeup_timer(args) {
+//     // Parse arguments if needed
+//     if (typeof args === 'string') {
+//         try {
+//             args = JSON.parse(args);
+//         } catch (e) {
+//             return "Error: Invalid arguments format";
+//         }
+//     }
+    
+//     // Check required arguments
+//     const seconds = args?.seconds;
+//     if (seconds === undefined || seconds < 0) {
+//         return "Error: seconds not specified or invalid";
+//     }
+    
+//     const message = args?.message;
+//     if (!message) {
+//         return "Error: message not specified";
+//     }
+    
+//     // Create a unique ID for the timer
+//     const timer_id = Date.now().toString() + Math.random().toString(36).substr(2, 5);
+    
+//     // Calculate expiry time
+//     const expiry_time = new Date(Date.now() + seconds * 1000);
+    
+//     // Create timer object
+//     const timer = {
+//         id: timer_id,
+//         seconds: seconds,
+//         message: message,
+//         created_time: new Date(),
+//         expiry_time: expiry_time
+//     };
+    
+//     // Add to wakeup schedule
+//     wakeup_timers.push(timer);
+    
+//     // Set the JavaScript timeout
+//     setTimeout(() => {
+//         // Add message to chat
+//         const chatBox = document.getElementById("chatBox");
+//         const messageDiv = document.createElement("div");
+//         messageDiv.className = "user-text";
+//         messageDiv.textContent = "WAKEUP:" + message;
+//         chatBox.appendChild(messageDiv);
+//         chatBox.scrollTop = chatBox.scrollHeight;
+        
+//         add_text_to_debug("Wakeup timer triggered: " + message);
+        
+//         // Remove from wakeup schedule
+//         const index = wakeup_timers.findIndex(t => t.id === timer_id);
+//         if (index !== -1) {
+//             wakeup_timers.splice(index, 1);
+//         }
+//     }, seconds * 1000);
+    
+//     return "Wakeup timer set for " + seconds + " seconds from now with message: " + message;
+// }
+
+function get_wakeup_timers(args) {
+    // Parse arguments if needed
+    if (typeof args === 'string') {
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            return "Error: Invalid arguments format";
+        }
+    }
+    
+    // Extract the message filter pattern if provided
+    const message_pattern = args?.message;
+    
+    // If no timers exist, return empty array
+    if (!wakeup_timers || wakeup_timers.length === 0) {
+        return "No active wakeup timers";
+    }
+    
+    // If a message pattern is provided, filter the timers
+    if (message_pattern) {
+        try {
+            const pattern = new RegExp(message_pattern);
+            const filtered_timers = wakeup_timers.filter(timer => 
+                pattern.test(timer.message)
+            );
+            
+            if (filtered_timers.length === 0) {
+                return "No timers match the pattern: " + message_pattern;
+            }
+            
+            // Return filtered timers with readable time information
+            const formatted_timers = filtered_timers.map(timer => ({
+                id: timer.id,
+                message: timer.message,
+                seconds_remaining: Math.max(0, Math.round((timer.expiry_time - new Date()) / 1000)),
+                expires_at: timer.expiry_time.toLocaleString()
+            }));
+            
+            return JSON.stringify(formatted_timers);
+        } catch (e) {
+            return "Error: Invalid regex pattern: " + e.message;
+        }
+    }
+    
+    // Return all timers with readable time information
+    const formatted_timers = wakeup_timers.map(timer => ({
+        id: timer.id,
+        message: timer.message,
+        seconds_remaining: Math.max(0, Math.round((timer.expiry_time - new Date()) / 1000)),
+        expires_at: timer.expiry_time.toLocaleString()
+    }));
+    
+    return JSON.stringify(formatted_timers);
+}
+
   class EventHandler extends EventEmitter {
         constructor(client) {
             super()
@@ -709,23 +1711,73 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
         }
 
         // handle requires action event by calling a local function and returning the result to the assistant
+        // async handleRequiresAction(data, runId, threadId) {
+        //     try {
+        //         // const toolOutputs = data.required_action.submit_tool_outputs.tool_calls.map((toolCall) => {
+        //         //     let output = handle_function_call(toolCall.function.name, toolCall.function.arguments)
+        //         //     output = JSON.stringify(output);
+        //         //     add_text_to_debug("fn:" + toolCall.function.name + " output:" + output)
+        //         //     return {
+        //         //         tool_call_id: toolCall.id,
+        //         //         output: output
+        //         //     }
+        //         // })
+
+        //         const toolOutputs = data.required_action.submit_tool_outputs.tool_calls.map((toolCall) => {
+        //         let output = handle_function_call(toolCall.function.name, toolCall.function.arguments);
+        //         // Check if output is already a string
+        //         if (typeof output !== 'string') {
+        //             output = JSON.stringify(output);
+        //         }
+        //         add_text_to_debug("fn:" + toolCall.function.name + " output:" + output);
+        //         return {
+        //             tool_call_id: toolCall.id,
+        //             output: output
+        //         }
+        //     })
+
+        //         // submit all the tool outputs at the same time
+        //         await this.submitToolOutputs(toolOutputs, runId, threadId)
+        //     } catch (error) {
+        //         console.error("Error processing required action:", error)
+        //     }
+        // }
+
         async handleRequiresAction(data, runId, threadId) {
+    try {
+        add_text_to_debug("Processing function calls: " + 
+            JSON.stringify(data.required_action.submit_tool_outputs.tool_calls.map(c => c.function.name)));
+        
+        const toolOutputs = data.required_action.submit_tool_outputs.tool_calls.map((toolCall) => {
+            add_text_to_debug("Calling function: " + toolCall.function.name);
+            add_text_to_debug("With args: " + toolCall.function.arguments);
+            
+            let output;
             try {
-                const toolOutputs = data.required_action.submit_tool_outputs.tool_calls.map((toolCall) => {
-                    let output = handle_function_call(toolCall.function.name, toolCall.function.arguments)
-                    add_text_to_debug("fn:" + toolCall.function.name + " output:" + output)
-                    return {
-                        tool_call_id: toolCall.id,
-                        output: output
-                    }
-                })
-
-                // submit all the tool outputs at the same time
-                await this.submitToolOutputs(toolOutputs, runId, threadId)
-            } catch (error) {
-                console.error("Error processing required action:", error)
+                output = handle_function_call(toolCall.function.name, toolCall.function.arguments);
+                // Check if output is already a string
+                if (typeof output !== 'string') {
+                    output = JSON.stringify(output);
+                }
+                add_text_to_debug("Function returned: " + output);
+            } catch (err) {
+                add_text_to_debug("ERROR in function call: " + err.message);
+                output = JSON.stringify({error: err.message});
             }
-        }
+            
+            return {
+                tool_call_id: toolCall.id,
+                output: output
+            }
+        });
+        
+        add_text_to_debug("Submitting tool outputs: " + JSON.stringify(toolOutputs));
+        await this.submitToolOutputs(toolOutputs, runId, threadId);
+    } catch (error) {
+        add_text_to_debug("ERROR in handleRequiresAction: " + error.message);
+        console.error("Error processing required action:", error);
+    }
+}
 
         // return function call results to the assistant
         async submitToolOutputs(toolOutputs, runId, threadId) {