From 12f9ecbf4f59f65be4d4296cd7ab452198bc70e1 Mon Sep 17 00:00:00 2001
From: codemaster1104 <akshatshrivastava1823@gmail.com>
Date: Sun, 23 Mar 2025 23:15:31 +0530
Subject: [PATCH 1/3] corrected message handling

---
 Chat/index.html | 144 +++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 129 insertions(+), 15 deletions(-)

diff --git a/Chat/index.html b/Chat/index.html
index 8c5c5dbf..32d80283 100644
--- a/Chat/index.html
+++ b/Chat/index.html
@@ -96,7 +96,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
   <!-- MAVLink connection button -->
   <div class="mavlink-connection-container">
       <label for="MAVLinkConnection">MAVLink Connect:</label>
-      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:56781" readonly>
+      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:8765" readonly>
       <button id="mavlink-connect-button">Connect</button>
   </div>
 
@@ -116,6 +116,8 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
     // imports
     import { mavlink_store } from './MAVLink/mavlink_store.js';
 
+    let latest_heartbeat_message = null;
+
     // show/hide the OpenAI API key field
     function toggle_openai_api_key_visibility() {
         let openai_key_input = document.getElementById("openai_api_key");
@@ -179,24 +181,99 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
                 mavlink_disconnect();
             };
 
+
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             // parse incoming message and forward
             mavlink_ws.onmessage = (msg) => {
                 // sanity check parser has been created
                 if (MAVLink == null) {
                     return;
                 }
+                // add_text_to_debug(msg.data);
+
+                const json_data = JSON.parse(msg.data);
+                // add_text_to_debug("Received: " + json_data.mavpackettype);
+                const mavlink_msg = createMavlinkMsgFromJson(json_data);
+
                 // parse message
-                for (const char of new Uint8Array(msg.data)) {
-                    const mavlink_msg = MAVLink.parseChar(char)
-                    if ((mavlink_msg != null) && (mavlink_msg._id != -1)) {
-                        // got a message with a known ID
-                        mavlink_msg_handler(mavlink_msg);
-                    }
+                if (mavlink_msg) {
+                    mavlink_msg_handler(mavlink_msg);
+                    // add_text_to_debug("done and dusted");
+                }
+                else add_text_to_debug("❌❌❌❌no msg");
+                
+            }
+            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+        }
+    }
+
+    // Add this function to convert JSON to MAVLink-compatible format
+    function createMavlinkMsgFromJson(json) {
+        if (!json || !json.mavpackettype) {
+            add_text_to_debug("❌ Invalid message format");
+            return null;
+        }
+        
+        try {
+            // Create a base object that preserves all original fields
+            const result = {
+                ...json,
+                // Add required fields for mavlink_store
+                _id: getMavlinkMessageId(json.mavpackettype),
+                _header: {
+                    srcSystem: 1,  // Default system ID
+                    srcComponent: 1  // Default component ID
                 }
+            };
+            
+            // Special handling for HEARTBEAT messages
+            if (json.mavpackettype === "HEARTBEAT") {
+                // add_text_to_debug("⭐ Received heartbeat message");
+                // Store directly for quick access
+                latest_heartbeat_message = result;
             }
+            
+            return result;
+        } catch (error) {
+            add_text_to_debug("❌ Error creating MAVLink message: " + error.message);
+            return null;
         }
     }
 
+    // Helper function to map common message types to IDs
+    function getMavlinkMessageId(msgType) {
+        if (msgType.toUpperCase() === "HEARTBEAT") {
+            return 0;  // Always use 0 for HEARTBEAT
+        }
+        const messageMap = {
+            "HEARTBEAT": 0,
+            "heartbeat": 0,
+            "SYS_STATUS": 1,
+            "PARAM_VALUE": 22,
+            "GPS_RAW_INT": 24,
+            "ATTITUDE": 30,
+            "GLOBAL_POSITION_INT": 33,
+            "RC_CHANNELS_RAW": 35,
+            "SERVO_OUTPUT_RAW": 36,
+            "MISSION_ITEM": 39,
+            "MISSION_REQUEST": 40,
+            "MISSION_ACK": 47,
+            "GPS_GLOBAL_ORIGIN": 49,
+            "NAV_CONTROLLER_OUTPUT": 62,
+            "RC_CHANNELS": 65,
+            "VFR_HUD": 74,
+            "COMMAND_LONG": 76,
+            "COMMAND_ACK": 77,
+            "ATTITUDE_QUATERNION": 31,
+            "LOCAL_POSITION_NED": 32,
+            "POSITION_TARGET_LOCAL_NED": 85,
+            "POSITION_TARGET_GLOBAL_INT": 87,
+            "STATUSTEXT": 253
+        };
+        
+        return messageMap[msgType] || -1;  // Return -1 for unknown types
+    }
     // disconnect from the vehicle
     function mavlink_disconnect() {
         if (mavlink_ws != null) {
@@ -213,25 +290,27 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
             return;
         }
 
+
         // store the message in the message store
         mavlink_store.store_message(msg);
 
         switch (msg._id) {
             case 0: // HEARTBEAT
-                //alert("custom mode:" + msg.custom_mode);
-                //alert("Got a heartbeat: " + JSON.stringify(msg));
+                // alert("custom mode:" + msg.custom_mode);
+                // add_text_to_debug("HEARTBEAT message processed in switch statement!");
+                // alert("Got a heartbeat: " + JSON.stringify(msg));
                 break;
             case 1: // SYS_STATUS
-                //alert("Got a system status: " + JSON.stringify(msg));
+                // alert("Got a system status: " + JSON.stringify(msg));
                 break;
             case 24: // GPS_RAW_INT
                 //alert("Got a GPS raw int: " + JSON.stringify(msg));
                 break;
             case 30: // ATTITUDE
-                //alert("Got an attitude: " + JSON.stringify(msg));
+                // alert("Got an attitude: " + JSON.stringify(msg));
                 break;
             case 33: // GLOBAL_POSITION_INT
-                //alert("Got a global position int: " + JSON.stringify(msg));
+                // alert("Got a global position int: " + JSON.stringify(msg));
                 break;
             case 35: // HIGHRES_IMU
                 //alert("Got a high resolution IMU: " + JSON.stringify(msg));
@@ -246,7 +325,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
                 //alert("Got a status text: " + JSON.stringify(msg));
                 break;
             default:
-                //alert("Got a message id: " + JSON.stringify(msg));
+                // alert("Got a message id: " + JSON.stringify(msg));
                 break;
         }
     }
@@ -518,7 +597,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
               // fallthrough
           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
@@ -528,6 +607,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
           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();
           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
@@ -641,6 +721,40 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
       return new Date().toLocaleString('en-US', options);
   }
 
+  function get_vehicle_location_and_yaw() {
+    // Get the latest GLOBAL_POSITION_INT message
+    const position_msg = mavlink_store.get_latest_message(33);
+    add_text_to_debug(position_msg);
+    if (!position_msg) {
+        return JSON.stringify({
+            error: "No position information available"
+        });
+    }
+    
+    // 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_msl: position_msg.alt / 1000.0,         // mm to meters
+        altitude_relative: 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);
+}
+
   class EventHandler extends EventEmitter {
         constructor(client) {
             super()
@@ -746,4 +860,4 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
     }
 </script>
 </body>
-</html>
+</html>
\ No newline at end of file

From 00429a54748db33218c0ae3193ff13f4bd902576 Mon Sep 17 00:00:00 2001
From: codemaster1104 <akshatshrivastava1823@gmail.com>
Date: Mon, 11 Aug 2025 21:41:50 +0530
Subject: [PATCH 2/3] update

---
 Chat/i2.html    | 1226 ++++++++++++++++++++++++++++++++
 Chat/i3.html    | 1801 +++++++++++++++++++++++++++++++++++++++++++++++
 Chat/index.html |  283 ++++----
 3 files changed, 3183 insertions(+), 127 deletions(-)
 create mode 100644 Chat/i2.html
 create mode 100644 Chat/i3.html

diff --git a/Chat/i2.html b/Chat/i2.html
new file mode 100644
index 00000000..eb5edb2f
--- /dev/null
+++ b/Chat/i2.html
@@ -0,0 +1,1226 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Chat</title>
+  <link rel="icon" href="../images/AP_favicon.png">
+  <script type="text/javascript" src="MAVLink/mavlink.js"></script>
+</head>
+<table style="width:1200px">
+  <tr>
+    <td>
+      <a href="https://ardupilot.org"><img src="../images/ArduPilot.png"></a>
+    </td>
+    <td>
+      <a href="https://github.com/ArduPilot/WebTools"><img src="../images/github-mark.png" style="width:60px"></a><br>
+      <a href="https://github.com/ArduPilot/WebTools"><img src="../images/GitHub_Logo.png" style="width:60px"></a>
+    </td>
+  </tr>
+</table>
+
+<style>
+    body {
+        font-family: Arial, sans-serif;
+    }
+    .chat-container {
+        width: 400px;
+        border: 1px solid #ccc;
+        border-radius: 5px;
+        padding: 10px;
+        background-color: #f9f9f9;
+    }
+    .chat-box {
+        width: 100%;
+        height: 200px;
+        border: 1px solid #ccc;
+        background-color: white;
+        padding: 5px;
+        overflow-y: auto;
+    }
+    .user-text {
+        color: red;
+    }
+    .assistant-text {
+        color: black;
+    }
+    .input-container {
+        display: flex;
+        margin-top: 10px;
+    }
+    .input-field {
+        flex: 1;
+        padding: 5px;
+    }
+    .send-button {
+        margin-left: 5px;
+    }
+</style>
+
+<h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
+
+<body>
+  <div class="chat-container">
+    <div class="chat-box" id="chatBox"></div>
+    <div class="input-container">
+        <button id="sendButton">Rec</button>
+        <input type="text" id="userInput" class="input-field" placeholder="Type a message...">
+        <button class="send-button" id="sendMessageButton" >Send</button>
+    </div>
+  </div>
+
+  <!-- OpenAI API key input field -->
+  <div class="openaiapi-key-container">
+    <label for="openai_api_key">OpenAI API Key:</label>
+    <input type="password" id="openai_api_key" class="input-field">
+    <button onclick="toggle_openai_api_key_visibility()">👁️</button>
+  </div>
+
+  <!-- read-only input for Assistant ID -->
+  <div class="assistant-id-container">
+    <label for="assistantId">assistant id:</label>
+    <input type="text" id="assistantId" class="input-field" readonly>
+  </div>
+
+  <!-- read-only input for assistant thread id -->
+  <div class="assistant-thread-container">
+    <label for="assistantThreadId">thread id:</label>
+    <input type="text" id="assistantThreadId" class="input-field" readonly>
+  </div>
+
+  <!-- read-only input for Assistant status -->
+  <div class="assistant-run-status-container">
+    <label for="assistantRunStatus">run status:</label>
+    <input type="text" id="assistantRunStatus" class="input-field" readonly>
+  </div>
+
+  <!-- MAVLink connection button -->
+  <div class="mavlink-connection-container">
+      <label for="MAVLinkConnection">MAVLink Connect:</label>
+      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:8765" readonly>
+      <button id="mavlink-connect-button">Connect</button>
+  </div>
+
+  <!-- MAVLink arming button -->
+  <div class="mavlink-arm-container">
+      <label for="mavlink-arm-vehicle">Arm Vehicle</label>
+      <button id="mavlink-arm-button">Arm</button>
+  </div>
+
+  <!-- debug output text box -->
+  <div class="debug-output-container">
+      <textarea id="debugOutput" class="input-field" rows="10" readonly></textarea>
+  </div>
+
+  <!-- simple script functions local to this page -->
+  <script type="module">
+    // imports
+    import { mavlink_store } from './MAVLink/mavlink_store.js';
+
+    let latest_heartbeat_message = null;
+
+    // show/hide the OpenAI API key field
+    function toggle_openai_api_key_visibility() {
+        let openai_key_input = document.getElementById("openai_api_key");
+        openai_key_input.type = openai_key_input.type === "password" ? "text" : "password";
+    }
+
+    // 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_sysid = 254; // system id
+    let mavlink_compid = MAVLink20Processor.MAV_COMP_ID_MISSIONPLANNER; // component id
+    let MAVLink = new MAVLink20Processor(null, mavlink_sysid, mavlink_compid);
+
+    // toggle connection state (called by Connect/Disconnect button)
+    function mavlink_toggle_connect() {
+        if (is_connected) {
+            mavlink_disconnect();
+        } else {
+            mavlink_connect();
+        }
+    }
+
+    // attach event listener to the connect button
+    if (connect_button) {
+        connect_button.addEventListener("click", mavlink_toggle_connect);
+    }
+
+    // set the mavlink button connection state
+    function mavlink_set_connect_state(connected) {
+        is_connected = connected;
+        if (connected) {
+            connect_button.innerText = "Disconnect";
+        } else {
+            connect_button.innerText = "Connect";
+        }
+    }
+
+    // connect to the vehicle
+    function mavlink_connect() {
+        // check connection URL
+        let connect_url = document.getElementById("mavlink-connect-url").value;
+        if (!connect_url) {
+            alert("Error: WebSocket URL is empty");
+            return;
+        }
+
+        if (mavlink_ws == null) {
+            // create a new websocket connection
+            mavlink_ws = new WebSocket(connect_url);
+            mavlink_ws.binaryType = "arraybuffer"
+
+            // set up event handlers
+            mavlink_ws.onopen = function() {
+                mavlink_set_connect_state(true);
+            };
+            mavlink_ws.onclose = function() {
+                mavlink_set_connect_state(false);
+            };
+            mavlink_ws.onerror = function() {
+                mavlink_disconnect();
+            };
+
+
+            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+            // parse incoming message and forward
+            mavlink_ws.onmessage = (msg) => {
+                // sanity check parser has been created
+                if (MAVLink == null) {
+                    return;
+                }
+                // add_text_to_debug(msg.data);
+
+                const json_data = JSON.parse(msg.data);
+                // add_text_to_debug("Received: " + json_data.mavpackettype);
+                const mavlink_msg = createMavlinkMsgFromJson(json_data);
+
+                // parse message
+                if (mavlink_msg) {
+                    mavlink_msg_handler(mavlink_msg);
+                    // add_text_to_debug("done and dusted");
+                }
+                else add_text_to_debug("❌❌❌❌no msg");
+                
+            }
+            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+        }
+    }
+
+    // Add this function to convert JSON to MAVLink-compatible format
+    function createMavlinkMsgFromJson(json) {
+        if (!json || !json.mavpackettype) {
+            add_text_to_debug("❌ Invalid message format");
+            return null;
+        }
+        
+        try {
+            // Create a base object that preserves all original fields
+            const result = {
+                ...json,
+                // Add required fields for mavlink_store
+                _id: getMavlinkMessageId(json.mavpackettype),
+                _header: {
+                    srcSystem: 1,  // Default system ID
+                    srcComponent: 1  // Default component ID
+                }
+            };
+            
+            // Special handling for HEARTBEAT messages
+            if (json.mavpackettype === "HEARTBEAT") {
+                // add_text_to_debug("⭐ Received heartbeat message");
+                // Store directly for quick access
+                latest_heartbeat_message = result;
+            }
+            
+            return result;
+        } catch (error) {
+            add_text_to_debug("❌ Error creating MAVLink message: " + error.message);
+            return null;
+        }
+    }
+
+    // Helper function to map common message types to IDs
+    function getMavlinkMessageId(msgType) {
+        if (msgType.toUpperCase() === "HEARTBEAT") {
+            return 0;  // Always use 0 for HEARTBEAT
+        }
+        const messageMap = {
+            "HEARTBEAT": 0,
+            "heartbeat": 0,
+            "SYS_STATUS": 1,
+            "PARAM_VALUE": 22,
+            "GPS_RAW_INT": 24,
+            "ATTITUDE": 30,
+            "GLOBAL_POSITION_INT": 33,
+            "RC_CHANNELS_RAW": 35,
+            "SERVO_OUTPUT_RAW": 36,
+            "MISSION_ITEM": 39,
+            "MISSION_REQUEST": 40,
+            "MISSION_ACK": 47,
+            "GPS_GLOBAL_ORIGIN": 49,
+            "NAV_CONTROLLER_OUTPUT": 62,
+            "RC_CHANNELS": 65,
+            "VFR_HUD": 74,
+            "COMMAND_LONG": 76,
+            "COMMAND_ACK": 77,
+            "ATTITUDE_QUATERNION": 31,
+            "LOCAL_POSITION_NED": 32,
+            "POSITION_TARGET_LOCAL_NED": 85,
+            "POSITION_TARGET_GLOBAL_INT": 87,
+            "STATUSTEXT": 253
+        };
+        
+        return messageMap[msgType] || -1;  // Return -1 for unknown types
+    }
+    // disconnect from the vehicle
+    function mavlink_disconnect() {
+        if (mavlink_ws != null) {
+            mavlink_ws.close();
+            mavlink_ws = null;
+        }
+    }
+
+    // mavlink message handler
+    function mavlink_msg_handler(msg) {
+
+        // sanity check msg
+        if (msg == null || msg._id == null) {
+            return;
+        }
+
+
+        // store the message in the message store
+        mavlink_store.store_message(msg);
+
+        switch (msg._id) {
+            case 0: // HEARTBEAT
+                // alert("custom mode:" + msg.custom_mode);
+                // add_text_to_debug("HEARTBEAT message processed in switch statement!");
+                // alert("Got a heartbeat: " + JSON.stringify(msg));
+                break;
+            case 1: // SYS_STATUS
+                // alert("Got a system status: " + JSON.stringify(msg));
+                break;
+            case 24: // GPS_RAW_INT
+                //alert("Got a GPS raw int: " + JSON.stringify(msg));
+                break;
+            case 30: // ATTITUDE
+                // alert("Got an attitude: " + JSON.stringify(msg));
+                break;
+            case 33: // GLOBAL_POSITION_INT
+                // alert("Got a global position int: " + JSON.stringify(msg));
+                break;
+            case 35: // HIGHRES_IMU
+                //alert("Got a high resolution IMU: " + JSON.stringify(msg));
+                break;
+            case 42: // NAMED_VALUE_FLOAT
+                //alert("Got a named value float: " + JSON.stringify(msg));
+                break;
+            case 74: // VFR_HUD
+                //alert("Got a VFR HUD: " + JSON.stringify(msg));
+                break;
+            case 253: // STATUSTEXT
+                //alert("Got a status text: " + JSON.stringify(msg));
+                break;
+
+            case 77: // COMMAND_ACK
+                add_text_to_debug("Got COMMAND_ACK: " + 
+                                "command=" + msg.command + 
+                                ", result=" + msg.result);
+                break;
+            default:
+                // alert("Got a message id: " + JSON.stringify(msg));
+                break;
+        }
+    }
+
+    // arm the vehicle
+    // function mavlink_arm_vehicle() {
+    //     if (mavlink_ws == null || mavlink_ws.readyState !== WebSocket.OPEN) {
+    //         alert("Please connect to the vehicle first");
+    //         return;
+    //     }
+    //     // construct the ARM command using COMMAND_LONG
+    //     let command_long_msg = new mavlink20.messages.command_long(
+    //         1,   // Target system ID
+    //         1,  // Target component ID
+    //         400,             // MAV_CMD_COMPONENT_ARM_DISARM (command ID 400)
+    //         1,               // Confirmation
+    //         1,               // Param1: 1 to arm, 0 to disarm
+    //         0, 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 ARM command via MAVLink");
+    //     } else {
+    //         alert("WebSocket is not open. Cannot send ARM command.");
+    //     }
+    // }
+
+    function mavlink_arm_vehicle() {
+        if (mavlink_ws == null || mavlink_ws.readyState !== WebSocket.OPEN) {
+            alert("Please connect to the vehicle first");
+            return;
+        }
+        
+        // Create JSON format COMMAND_LONG message for arming
+        const arm_command = {
+            "mavpackettype": "COMMAND_LONG",
+            "target_system": 1,
+            "target_component": 1,
+            "command": 400,  // MAV_CMD_COMPONENT_ARM_DISARM
+            "confirmation": 1,
+            "param1": 1,     // 1 to arm, 0 to disarm
+            "param2": 0,
+            "param3": 0,
+            "param4": 0,
+            "param5": 0,
+            "param6": 0,
+            "param7": 0
+        };
+        
+        // Send as JSON string
+        mavlink_ws.send(JSON.stringify(arm_command));
+        add_text_to_debug("Sent ARM command via MAVLink (JSON format)");
+        
+        // Listen for COMMAND_ACK in your message handler
+        add_text_to_debug("Waiting for acknowledgment...");
+    }
+    // attach event listener to the arm button
+    document.getElementById("mavlink-arm-button").addEventListener("click", mavlink_arm_vehicle);
+
+    // 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;
+    }
+</script>
+
+<script type="module">
+  // error handling
+  window.onerror = function(msg, url, linenumber) {
+      alert('Sorry, something went wrong.\n\n' + 
+            'Please try a hard reload of this page to clear its cache.\n\n' +
+            'If the error persists open an issue on the GitHub repo.\n' +
+            'Include a copy of the log and the following error message:\n\n' +
+            msg + '\n' +
+            'URL: '+ url +'\n' +
+            'Line Number: '+ linenumber)
+      return false
+  }
+  window.addEventListener('unhandledrejection', function (e) {
+      throw new Error(e.reason.stack)
+  })
+
+  // imports
+  import OpenAI from 'https://cdn.jsdelivr.net/npm/openai@4.85.4/+esm'
+  import EventEmitter from 'https://cdn.jsdelivr.net/npm/eventemitter3@5.0.1/+esm'
+  import { mavlink_store } from './MAVLink/mavlink_store.js';
+
+  // constants
+  const OPENAI_API_KEY = ""; // replace with your OpenAI API key
+  const OPENAI_MODEL = "gpt-4o"
+  const OPENAI_ASSISTANT_NAME = "ArduPilot Vehicle Control via MAVLink"
+
+  // global variables
+  let openai = null
+  let openai_assistant_id = null
+  let openai_thread_id = null
+  let openai_event_handler = null
+
+  // chat listener for user input and enter key
+  document.getElementById("userInput").addEventListener("keypress", function(event) {
+      if (event.key === "Enter") {
+          send_message();
+      }
+  })
+  // listener for send message button click
+  document.getElementById("sendMessageButton").addEventListener("click", send_message);
+
+  // get openai API key (use this in API calls)
+  function get_openai_api_key() {
+      if (OPENAI_API_KEY.length > 0) {
+          return OPENAI_API_KEY;
+      }
+      return document.getElementById("openai_api_key").value.trim();
+  }
+
+  // check connection
+  check_connection();
+
+  // add text to chat box
+  function add_text_to_chat(text, role = "assistant") {
+      let div_class = role === "assistant" ? "assistant-text" : "user-text";
+      let chatBox = document.getElementById("chatBox");
+
+      if (role === "assistant") {
+          // try to find the last assistant message and append to it
+          let last_message = chatBox.querySelector(`.${div_class}:last-of-type`);
+          if (last_message) {
+              last_message.textContent += text;
+              chatBox.scrollTop = chatBox.scrollHeight;
+              return;
+          }
+      }
+
+      // create a new message div if no previous assistant message exists
+      let message_div = document.createElement("div");
+      message_div.className = div_class;
+      message_div.textContent = text;
+      chatBox.appendChild(message_div);
+      chatBox.scrollTop = chatBox.scrollHeight;
+  }
+
+  // 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;
+  }
+
+  // send message to AI assistant, get response and place in chat box text area
+  async function send_message() {
+      // check connection to OpenAI
+      if (!(await check_connection())) {
+          return;
+      }
+
+      let userInput = document.getElementById("userInput").value;
+      if (!userInput.trim()) return;
+
+      // display user input and clear input field
+      add_text_to_chat(userInput, "user");
+      document.getElementById("userInput").value = "";
+
+      // fetch response from assistant
+      let response = await get_assistant_response(userInput);
+
+      // display assistant response
+      add_text_to_chat(response, "assistant");
+  }
+
+  //
+  // methods below here interact directly with the OpenAI API
+  //
+
+  // check connection to OpenAI API and return true on succes, false on failure
+  async function check_connection() {
+      // check openai API key
+      if (!get_openai_api_key()) {
+          return false;
+      }
+      // check openai connection
+      if (!openai) {
+          openai = new OpenAI({apiKey: get_openai_api_key(), dangerouslyAllowBrowser: true});
+          if (!openai) {
+              return false;
+          }
+      }
+
+      // return immediately if assistant id has already been found
+      if (openai_assistant_id) {
+          return true
+      }
+
+      let assistantId = await find_assistant(OPENAI_ASSISTANT_NAME);
+      if (assistantId) {
+          // store assistant id
+          openai_assistant_id = assistantId
+          document.getElementById("assistantId").value = assistantId;
+
+          // create a new thread
+          openai_thread_id = await create_thread();
+          if (!openai_thread_id) {
+              alert("Error: Unable to create a new OpenAI thread");
+              return false;
+          }
+          // print thread id on the page
+          document.getElementById("assistantThreadId").value = openai_thread_id;
+
+          // setup event handler
+          openai_event_handler = new EventHandler(openai)
+          if (!openai_event_handler) {
+              alert("Error: Unable to create event handler");
+              return false;
+          }
+          openai_event_handler.on("event", openai_event_handler.onEvent.bind(openai_event_handler))
+          return true;
+      } else {
+          alert("Error: Assistant not found. Please check your OpenAI API key and assistant name");
+          return false;
+      }
+  }
+
+  // get assistant response based on user input
+  async function find_assistant(assistant_name) {
+      // sanity check openai connection
+      if (!openai) {
+          return null;
+      }
+
+      try {
+          // get a list of all assistants
+          const assistants_list = await openai.beta.assistants.list({order: "desc", limit: 20});
+
+          // iterate through assistants and find the one with the matching name
+          let assistant = assistants_list.data.find(a => a.name === assistant_name);
+
+          // return assistant ID if found, otherwise return null
+          return assistant ? assistant.id : null;
+      } catch (error) {
+          // return null in case of an error
+          return null;
+      }
+  }
+
+  // create a new thread
+  // returns thread id on success, null on failure
+  async function create_thread() {
+    // sanity check the assistant id
+    if (!openai_assistant_id) {
+        return null;
+    }
+
+    try {
+        // create a thread
+        const new_thread = await openai.beta.threads.create();
+        return new_thread ? new_thread.id : null;
+    } catch (error) {
+        return null;
+    }
+  }
+
+  // get assistant response based on user input
+  async function get_assistant_response(input) {
+      // sanity check the assistant id
+      if (!openai_assistant_id) {
+          return "get_assistant_response: assistant not found";
+      }
+      // sanity check thread
+      if (!openai_thread_id) {
+          return "get_assistant_response: thread not found";
+      }
+
+      // add a message to the thread
+      const message = await openai.beta.threads.messages.create(openai_thread_id, { role: "user", content: input });
+
+      // run the assistant
+      const stream = await openai.beta.threads.runs.stream(openai_thread_id, { assistant_id: openai_assistant_id, stream: true })
+      stream.on('event', (event) => openai_event_handler.emit("event", event))
+  }
+
+  // handle function call from assistant
+  function handle_function_call(name, args) {
+      add_text_to_debug("Function call: " + name + " with args: " + JSON.stringify(args));
+      // call the function
+      switch (name) {
+          case "get_vehicle_type":
+              // get the vehicle type (e.g. Copter, Plane, Rover, Boat, etc)
+              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
+              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
+          case "get_vehicle_location_and_yaw":
+              // Get the vehicle's current location including latitude, longitude, altitude above sea level and altitude above home
+              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
+              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();
+          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
+              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
+          case "get_parameter_description":
+              // Get vehicle parameter descriptions including description, units, min and max
+              // fallthrough
+          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
+          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);
+              return "Unknown function: " + name;
+          case "get_current_datetime":
+              // Get the current date and time, e.g. 'Saturday, June 24, 2023 6:14:14 PM
+              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
+              return get_mode_mapping(args);
+          case "get_all_parameters":
+              // Get all available parameter names and values
+              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);
+              return "Unknown function: " + name;
+          case "get_available_mavlink_messages":
+              return get_available_mavlink_messages();
+          default:
+              add_text_to_debug("Unknown function: " + name);
+              return "Unknown function: " + name;
+      }
+  }
+
+    // function calls below here
+    // returns "Copter", "Plane", "Rover", "Boat", etc or "Unknown"
+    function get_vehicle_type() {
+
+        // get the latest HEARTBEAT message and perform a sanity check
+        let heartbeat_msg = mavlink_store.get_latest_message(0);
+        //add_text_to_debug("get_vehicle_type: got latest msg" + JSON.stringify(heartbeat_msg));
+        if (!heartbeat_msg || !heartbeat_msg.hasOwnProperty("type")) {
+            return "unknown because no HEARTBEAT message has been received from the vehicle";
+        }
+        let vehicle_type = heartbeat_msg["type"];
+
+        // get the vehicle type from the heartbeat message's type field
+        switch (vehicle_type) {
+            case mavlink20.MAV_TYPE_FIXED_WING:
+            case mavlink20.MAV_TYPE_VTOL_DUOROTOR:
+            case mavlink20.MAV_TYPE_VTOL_QUADROTOR:
+            case mavlink20.MAV_TYPE_VTOL_TILTROTOR:
+                return "Plane"
+            case mavlink20.MAV_TYPE_GROUND_ROVER:
+                return "Rover";
+            case mavlink20.MAV_TYPE_SURFACE_BOAT:
+                return "Boat";
+            case mavlink20.MAV_TYPE_SUBMARINE:
+                return "Sub";
+            case mavlink20.MAV_TYPE_QUADROTOR:
+            case mavlink20.MAV_TYPE_COAXIAL:
+            case mavlink20.MAV_TYPE_HEXAROTOR:
+            case mavlink20.MAV_TYPE_OCTOROTOR:
+            case mavlink20.MAV_TYPE_TRICOPTER:
+            case mavlink20.MAV_TYPE_DODECAROTOR:
+                return "Copter";
+            case mavlink20.MAV_TYPE_HELICOPTER:
+                return "Heli";
+            case mavlink20.MAV_TYPE_ANTENNA_TRACKER:
+                return "Tracker";
+            case mavlink20.MAV_TYPE_AIRSHIP:
+                return "Blimp";
+            default:
+                add_text_to_debug("get_vehicle_type: default, unknown");
+                return "unknown";
+        }
+
+        // if we got this far  we don't know the vehicle type
+        add_text_to_debug("get_vehicle_type: no match for type:" + hearbeat_msg.type);
+        return "unknown";
+    }
+
+    // get names of all available mavlink messages
+    function get_available_mavlink_messages() {
+        // get the available message names
+        let msg_names = mavlink_store.get_available_message_names();
+        if (!msg_names) {
+            return "No available messages";
+        }
+        return msg_names.join(", ");
+    }
+
+  // get the current time and date as a string. E.g. 'Saturday, June 24, 2023 6:14:14 PM'
+  function getFormattedDate() {
+      const options = {
+          weekday: 'long', 
+          year: 'numeric', 
+          month: 'long', 
+          day: 'numeric', 
+          hour: 'numeric', 
+          minute: 'numeric', 
+          second: 'numeric', 
+          hour12: true 
+      };
+      return new Date().toLocaleString('en-US', options);
+  }
+
+  function get_vehicle_location_and_yaw() {
+    // Get the latest GLOBAL_POSITION_INT message
+    const position_msg = mavlink_store.get_latest_message(33);
+    add_text_to_debug(position_msg);
+    if (!position_msg) {
+        return JSON.stringify({
+            error: "No position information available"
+        });
+    }
+    
+    // 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_msl: position_msg.alt / 1000.0,         // mm to meters
+        altitude_relative: 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);
+}
+
+function get_all_parameters() {
+    // Get all PARAM_VALUE messages from the mavlink store
+    // First check if any parameters are available
+    let 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 by iterating through stored messages
+    // This is a simplification - in a real system you'd have a parameter cache
+    let param_list = {};
+    
+    // Get all available systems and components
+    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 there are any PARAM_VALUE messages for this system/component
+            if (mavlink_store.store[sysid][compid][22]) {
+                // For each parameter, add it to our list
+                // Note: This only gets the latest parameter value
+                const param = mavlink_store.store[sysid][compid][22];
+                if (param.param_id) {
+                    param_list[param.param_id] = param.param_value;
+                }
+            }
+        }
+    }
+    
+    // If no parameters were found, return an error
+    if (Object.keys(param_list).length === 0) {
+        return JSON.stringify({
+            error: "No parameters found in MAVLink store"
+        });
+    }
+    
+    // Return the parameter list as a 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" });
+        }
+    }
+    
+    const param_name = args.name;
+    if (!param_name) {
+        return JSON.stringify({ error: "Parameter name not specified" });
+    }
+    
+    // Check if we have any parameters
+    let 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." 
+        });
+    }
+    
+    // Check if it's a regex pattern
+    const is_regex_pattern = /[.*+?^${}()|[\]\\]/.test(param_name);
+    
+    if (is_regex_pattern) {
+        // For regex matches, we need to check all stored parameters
+        try {
+            const regex = new RegExp(param_name);
+            const allParamsStr = get_all_parameters();
+            const allParams = JSON.parse(allParamsStr);
+            
+            if (allParams.error) {
+                return JSON.stringify({ error: allParams.error });
+            }
+            
+            // Filter parameters by regex
+            const matches = {};
+            for (const [name, value] of Object.entries(allParams)) {
+                if (regex.test(name)) {
+                    matches[name] = value;
+                }
+            }
+            
+            if (Object.keys(matches).length === 0) {
+                return JSON.stringify({ error: "No parameters match pattern: " + param_name });
+            }
+            
+            return JSON.stringify(matches);
+        } catch (error) {
+            return JSON.stringify({ error: "Error processing regex: " + error.message });
+        }
+    } else {
+        // For direct parameter name matching
+        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) {
+                if (mavlink_store.store[sysid][compid][22]) {
+                    const param = mavlink_store.store[sysid][compid][22];
+                    if (param.param_id === param_name) {
+                        const result = {};
+                        result[param_name] = param.param_value;
+                        return JSON.stringify(result);
+                    }
+                }
+            }
+        }
+        
+        return JSON.stringify({ error: "Parameter not found: " + param_name });
+    }
+}
+
+function get_vehicle_state() {
+    // Get the latest HEARTBEAT message
+    let heartbeat_msg = mavlink_store.get_latest_message(0);
+    if (!heartbeat_msg) {
+        return JSON.stringify({
+            armed: false,
+            mode: 0,
+            error: "No HEARTBEAT message received"
+        });
+    }
+    
+    // Extract armed status (base_mode bit 7 is the armed flag)
+    // In MAVLink, the armed status is in bit 7 (128) of the base_mode field
+    const base_mode = heartbeat_msg.base_mode || 0;
+    const custom_mode = heartbeat_msg.custom_mode || 0;
+    const armed = (base_mode & 128) !== 0;  // Check if bit 7 is set
+    
+    return JSON.stringify({
+        armed: armed,
+        mode: custom_mode
+    });
+}
+
+function get_mode_mapping(args) {
+    // Parse arguments if string
+    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?.toUpperCase();
+    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,
+            "FLOWHOLD": 22,
+            "FOLLOW": 23,
+            "ZIGZAG": 24,
+            "SYSTEMID": 25,
+            "AUTOROTATE": 26
+        },
+        "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,
+            "AVOID_ADSB": 14,
+            "GUIDED": 15,
+            "INITIALIZING": 16,
+            "QSTABILIZE": 17,
+            "QHOVER": 18,
+            "QLOITER": 19,
+            "QLAND": 20,
+            "QRTL": 21,
+            "QAUTOTUNE": 22,
+            "QACRO": 23
+        },
+        "Rover": {
+            "MANUAL": 0,
+            "ACRO": 1,
+            "STEERING": 3,
+            "HOLD": 4,
+            "LOITER": 5,
+            "FOLLOW": 6,
+            "SIMPLE": 7,
+            "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 send_mavlink_command_int(args) {
+    // Parse arguments if needed
+    if (typeof args === 'string') {
+        try {
+            args = JSON.parse(args);
+        } catch (e) {
+            return JSON.stringify({ error: "Invalid arguments format" });
+        }
+    }
+    
+    // Validate required arguments
+    if (!args.command) {
+        return JSON.stringify({ error: "command_int not sent. command field required" });
+    }
+    
+    // Check websocket connection
+    if (mavlink_ws == null || mavlink_ws.readyState !== WebSocket.OPEN) {
+        return JSON.stringify({ error: "WebSocket not connected. Please connect to vehicle first." });
+    }
+    
+    // Set default values for optional arguments
+    const target_system = args.target_system || 1;
+    const target_component = args.target_component || 1;
+    const frame = args.frame || 0;
+    const command = args.command;
+    const current = args.current || 0;
+    const autocontinue = args.autocontinue || 0;
+    const param1 = args.param1 || 0;
+    const param2 = args.param2 || 0;
+    const param3 = args.param3 || 0;
+    const param4 = args.param4 || 0;
+    const x = args.x || 0;
+    const y = args.y || 0;
+    const z = args.z || 0;
+    
+    // Specific command validations
+    if (command === 22 && z === 0) { // MAV_CMD_NAV_TAKEOFF = 22
+        return JSON.stringify({ error: "command_int not sent. MAV_CMD_NAV_TAKEOFF requires alt in z field" });
+    }
+    
+    // Create command_int message
+    const command_int_msg = {
+        "mavpackettype": "COMMAND_INT",
+        "target_system": target_system,
+        "target_component": target_component,
+        "frame": frame,
+        "command": command,
+        "current": current,
+        "autocontinue": autocontinue,
+        "param1": param1,
+        "param2": param2,
+        "param3": param3,
+        "param4": param4,
+        "x": x,
+        "y": y,
+        "z": z
+    };
+    
+    // Send command
+    add_text_to_debug("Sending COMMAND_INT: " + JSON.stringify(command_int_msg));
+    mavlink_ws.send(JSON.stringify(command_int_msg));
+    
+    // In a more sophisticated implementation, we would wait for the COMMAND_ACK
+    // This simplified version just returns that the command was sent
+    return JSON.stringify({
+        result: "command_int sent, check debug output for acknowledgment"
+    });
+}
+
+  class EventHandler extends EventEmitter {
+        constructor(client) {
+            super()
+            this.client = client;
+        }
+
+        async onEvent(event) {
+            try {
+                // print status on html page
+                document.getElementById("assistantRunStatus").value = event.event;
+
+                // handle each event
+                switch (event.event) {
+                // retrieve events that are denoted with 'requires_action'
+                // since these will have our tool_calls
+                case "thread.run.requires_action":
+                    await this.handleRequiresAction(
+                        event.data,
+                        event.data.id,
+                        event.data.thread_id,
+                    )
+                    break;
+                case "thread.message.delta":
+                case "thread.run.step.delta":
+                    let delta_text = event.data.delta.content[0].text.value
+                    add_text_to_chat(delta_text, "assistant")
+                    break;
+
+                // events below can be ignored
+                case "thread.created":
+                case "thread.message.completed":
+                case "thread.run.created":
+                case "thread.run.queued":
+                case "thread.run.in_progress":
+                case "thread.run.completed":
+                case "thread.run.incomplete":
+                case "thread.run.failed":
+                case "thread.run.step.created":
+                case "thread.run.cancelling":
+                case "thread.run.step.in_progress":
+                case "thread.run.cancelled":
+                case "thread.run.expired":
+                case "thread.run.step.created":
+                case "thread.run.step.in_progress":
+                case "thread.run.step.completed":
+                case "thread.run.step.failed":
+                case "thread.run.step.cancelled":
+                case "thread.run.step.expired":
+                case "thread.message.created":
+                case "thread.message.in_progress":
+                case "thread.message.completed":
+                case "thread.message.incomplete":
+                case "error":
+                case "done":
+                    break;
+
+                // catch unhandled events
+                default:
+                    add_text_to_debug("Unhandled event: " + event.event)
+                    console.log(event)
+                }
+
+            } catch (error) {
+                console.error("Error handling event:", error)
+            }
+        }
+
+        // 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)
+                    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)
+            }
+        }
+
+        // return function call results to the assistant
+        async submitToolOutputs(toolOutputs, runId, threadId) {
+            try {
+                // use the submitToolOutputsStream helper
+                const stream = this.client.beta.threads.runs.submitToolOutputsStream(
+                    threadId,
+                    runId,
+                    { tool_outputs: toolOutputs },
+                )
+                for await (const event of stream) {
+                    this.emit("event", event)
+                }
+            } catch (error) {
+                console.error("Error submitting tool outputs:", error)
+            }
+        }
+    }
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/Chat/i3.html b/Chat/i3.html
new file mode 100644
index 00000000..0c3b68e0
--- /dev/null
+++ b/Chat/i3.html
@@ -0,0 +1,1801 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Chat</title>
+  <link rel="icon" href="../images/AP_favicon.png">
+  <script type="text/javascript" src="MAVLink/mavlink.js"></script>
+</head>
+<table style="width:1200px">
+  <tr>
+    <td>
+      <a href="https://ardupilot.org"><img src="../images/ArduPilot.png"></a>
+    </td>
+    <td>
+      <a href="https://github.com/ArduPilot/WebTools"><img src="../images/github-mark.png" style="width:60px"></a><br>
+      <a href="https://github.com/ArduPilot/WebTools"><img src="../images/GitHub_Logo.png" style="width:60px"></a>
+    </td>
+  </tr>
+</table>
+
+<style>
+    body {
+        font-family: Arial, sans-serif;
+    }
+    .chat-container {
+        width: 400px;
+        border: 1px solid #ccc;
+        border-radius: 5px;
+        padding: 10px;
+        background-color: #f9f9f9;
+    }
+    .chat-box {
+        width: 100%;
+        height: 200px;
+        border: 1px solid #ccc;
+        background-color: white;
+        padding: 5px;
+        overflow-y: auto;
+    }
+    .user-text {
+        color: red;
+    }
+    .assistant-text {
+        color: black;
+    }
+    .input-container {
+        display: flex;
+        margin-top: 10px;
+    }
+    .input-field {
+        flex: 1;
+        padding: 5px;
+    }
+    .send-button {
+        margin-left: 5px;
+    }
+</style>
+
+<h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
+
+<body>
+  <div class="chat-container">
+    <div class="chat-box" id="chatBox"></div>
+    <div class="input-container">
+        <button id="sendButton">Rec</button>
+        <input type="text" id="userInput" class="input-field" placeholder="Type a message...">
+        <button class="send-button" id="sendMessageButton" >Send</button>
+    </div>
+  </div>
+
+  <!-- OpenAI API key input field -->
+  <div class="openaiapi-key-container">
+    <label for="openai_api_key">OpenAI API Key:</label>
+    <input type="password" id="openai_api_key" class="input-field">
+    <button onclick="toggle_openai_api_key_visibility()">👁️</button>
+  </div>
+
+  <!-- read-only input for Assistant ID -->
+  <div class="assistant-id-container">
+    <label for="assistantId">assistant id:</label>
+    <input type="text" id="assistantId" class="input-field" readonly>
+  </div>
+
+  <!-- read-only input for assistant thread id -->
+  <div class="assistant-thread-container">
+    <label for="assistantThreadId">thread id:</label>
+    <input type="text" id="assistantThreadId" class="input-field" readonly>
+  </div>
+
+  <!-- read-only input for Assistant status -->
+  <div class="assistant-run-status-container">
+    <label for="assistantRunStatus">run status:</label>
+    <input type="text" id="assistantRunStatus" class="input-field" readonly>
+  </div>
+
+  <!-- MAVLink connection button -->
+  <div class="mavlink-connection-container">
+      <label for="MAVLinkConnection">MAVLink Connect:</label>
+      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:56781" readonly>
+      <button id="mavlink-connect-button">Connect</button>
+  </div>
+
+  <!-- MAVLink arming button -->
+  <div class="mavlink-arm-container">
+      <label for="mavlink-arm-vehicle">Arm Vehicle</label>
+      <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>
+  </div>
+
+  <!-- simple script functions local to this page -->
+  <script type="module">
+    // imports
+    import { mavlink_store } from './MAVLink/mavlink_store.js';
+
+    // show/hide the OpenAI API key field
+    function toggle_openai_api_key_visibility() {
+        let openai_key_input = document.getElementById("openai_api_key");
+        openai_key_input.type = openai_key_input.type === "password" ? "text" : "password";
+    }
+
+    // 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_sysid = 254; // system id
+    let mavlink_compid = MAVLink20Processor.MAV_COMP_ID_MISSIONPLANNER; // component id
+    // 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() {
+        if (is_connected) {
+            mavlink_disconnect();
+        } else {
+            mavlink_connect();
+        }
+    }
+
+    // attach event listener to the connect button
+    if (connect_button) {
+        connect_button.addEventListener("click", mavlink_toggle_connect);
+    }
+
+    // set the mavlink button connection state
+    function mavlink_set_connect_state(connected) {
+        is_connected = connected;
+        if (connected) {
+            connect_button.innerText = "Disconnect";
+        } else {
+            connect_button.innerText = "Connect";
+        }
+    }
+
+    // connect to the vehicle
+    function mavlink_connect() {
+        // check connection URL
+        let connect_url = document.getElementById("mavlink-connect-url").value;
+        if (!connect_url) {
+            alert("Error: WebSocket URL is empty");
+            return;
+        }
+
+        if (mavlink_ws == null) {
+            // create a new websocket connection
+            mavlink_ws = new WebSocket(connect_url);
+            mavlink_ws.binaryType = "arraybuffer"
+
+            // set up event handlers
+            mavlink_ws.onopen = function() {
+                mavlink_set_connect_state(true);
+            };
+            mavlink_ws.onclose = function() {
+                mavlink_set_connect_state(false);
+            };
+            mavlink_ws.onerror = function() {
+                mavlink_disconnect();
+            };
+
+            // parse incoming message and forward
+            mavlink_ws.onmessage = (msg) => {
+                // sanity check parser has been created
+                if (MAVLink == null) {
+                    return;
+                }
+                // parse message
+                for (const char of new Uint8Array(msg.data)) {
+                    const mavlink_msg = MAVLink.parseChar(char)
+                    if ((mavlink_msg != null) && (mavlink_msg._id != -1)) {
+                        // got a message with a known ID
+                        mavlink_msg_handler(mavlink_msg);
+                    }
+                }
+            }
+        }
+    }
+
+    // disconnect from the vehicle
+    function mavlink_disconnect() {
+        if (mavlink_ws != null) {
+            mavlink_ws.close();
+            mavlink_ws = null;
+        }
+    }
+
+    // mavlink message handler
+    function mavlink_msg_handler(msg) {
+
+        // sanity check msg
+        if (msg == null || msg._id == null) {
+            return;
+        }
+
+        // store the message in the message store
+        mavlink_store.store_message(msg);
+
+        switch (msg._id) {
+            case 0: // HEARTBEAT
+                //alert("custom mode:" + msg.custom_mode);
+                //alert("Got a heartbeat: " + JSON.stringify(msg));
+                break;
+            case 1: // SYS_STATUS
+                //alert("Got a system status: " + JSON.stringify(msg));
+                break;
+            case 24: // GPS_RAW_INT
+                //alert("Got a GPS raw int: " + JSON.stringify(msg));
+                break;
+            case 30: // ATTITUDE
+                //alert("Got an attitude: " + JSON.stringify(msg));
+                break;
+            case 33: // GLOBAL_POSITION_INT
+                //alert("Got a global position int: " + JSON.stringify(msg));
+                break;
+            case 35: // HIGHRES_IMU
+                //alert("Got a high resolution IMU: " + JSON.stringify(msg));
+                break;
+            case 42: // NAMED_VALUE_FLOAT
+                //alert("Got a named value float: " + JSON.stringify(msg));
+                break;
+            case 74: // VFR_HUD
+                //alert("Got a VFR HUD: " + JSON.stringify(msg));
+                break;
+            case 253: // STATUSTEXT
+                //alert("Got a status text: " + JSON.stringify(msg));
+                break;
+            default:
+                //alert("Got a message id: " + JSON.stringify(msg));
+                break;
+        }
+    }
+
+    // arm the vehicle
+    function mavlink_arm_vehicle() {
+        if (mavlink_ws == null || mavlink_ws.readyState !== WebSocket.OPEN) {
+            alert("Please connect to the vehicle first");
+            return;
+        }
+        // construct the ARM command using COMMAND_LONG
+        let command_long_msg = new mavlink20.messages.command_long(
+            1,   // Target system ID
+            1,  // Target component ID
+            400,             // MAV_CMD_COMPONENT_ARM_DISARM (command ID 400)
+            1,               // Confirmation
+            1,               // Param1: 1 to arm, 0 to disarm
+            0, 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 ARM command via MAVLink");
+        } else {
+            alert("WebSocket is not open. Cannot send ARM command.");
+        }
+    }
+    // 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">
+  // error handling
+  window.onerror = function(msg, url, linenumber) {
+      alert('Sorry, something went wrong.\n\n' + 
+            'Please try a hard reload of this page to clear its cache.\n\n' +
+            'If the error persists open an issue on the GitHub repo.\n' +
+            'Include a copy of the log and the following error message:\n\n' +
+            msg + '\n' +
+            'URL: '+ url +'\n' +
+            'Line Number: '+ linenumber)
+      return false
+  }
+  window.addEventListener('unhandledrejection', function (e) {
+      throw new Error(e.reason.stack)
+  })
+
+  // imports
+  import OpenAI from 'https://cdn.jsdelivr.net/npm/openai@4.85.4/+esm'
+  import EventEmitter from 'https://cdn.jsdelivr.net/npm/eventemitter3@5.0.1/+esm'
+  import { mavlink_store } from './MAVLink/mavlink_store.js';
+
+  // constants
+  const OPENAI_API_KEY = ""; // replace with your OpenAI API key
+  const OPENAI_MODEL = "gpt-4o"
+  const OPENAI_ASSISTANT_NAME = "ArduPilot Vehicle Control via MAVLink"
+
+  // global variables
+  let openai = null
+  let openai_assistant_id = null
+  let openai_thread_id = null
+  let openai_event_handler = null
+
+  // chat listener for user input and enter key
+  document.getElementById("userInput").addEventListener("keypress", function(event) {
+      if (event.key === "Enter") {
+          send_message();
+      }
+  })
+  // listener for send message button click
+  document.getElementById("sendMessageButton").addEventListener("click", send_message);
+
+  // get openai API key (use this in API calls)
+  function get_openai_api_key() {
+      if (OPENAI_API_KEY.length > 0) {
+          return OPENAI_API_KEY;
+      }
+      return document.getElementById("openai_api_key").value.trim();
+  }
+
+  // check connection
+  check_connection();
+
+  // add text to chat box
+  function add_text_to_chat(text, role = "assistant") {
+      let div_class = role === "assistant" ? "assistant-text" : "user-text";
+      let chatBox = document.getElementById("chatBox");
+
+      if (role === "assistant") {
+          // try to find the last assistant message and append to it
+          let last_message = chatBox.querySelector(`.${div_class}:last-of-type`);
+          if (last_message) {
+              last_message.textContent += text;
+              chatBox.scrollTop = chatBox.scrollHeight;
+              return;
+          }
+      }
+
+      // create a new message div if no previous assistant message exists
+      let message_div = document.createElement("div");
+      message_div.className = div_class;
+      message_div.textContent = text;
+      chatBox.appendChild(message_div);
+      chatBox.scrollTop = chatBox.scrollHeight;
+  }
+
+  // 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;
+  }
+
+  // send message to AI assistant, get response and place in chat box text area
+  async function send_message() {
+      // check connection to OpenAI
+      if (!(await check_connection())) {
+          return;
+      }
+
+      let userInput = document.getElementById("userInput").value;
+      if (!userInput.trim()) return;
+
+      // display user input and clear input field
+      add_text_to_chat(userInput, "user");
+      document.getElementById("userInput").value = "";
+
+      // fetch response from assistant
+      let response = await get_assistant_response(userInput);
+
+      // display assistant response
+      add_text_to_chat(response, "assistant");
+  }
+
+  //
+  // methods below here interact directly with the OpenAI API
+  //
+
+  // check connection to OpenAI API and return true on succes, false on failure
+  async function check_connection() {
+      // check openai API key
+      if (!get_openai_api_key()) {
+          return false;
+      }
+      // check openai connection
+      if (!openai) {
+          openai = new OpenAI({apiKey: get_openai_api_key(), dangerouslyAllowBrowser: true});
+          if (!openai) {
+              return false;
+          }
+      }
+
+      // return immediately if assistant id has already been found
+      if (openai_assistant_id) {
+          return true
+      }
+
+      let assistantId = await find_assistant(OPENAI_ASSISTANT_NAME);
+      if (assistantId) {
+          // store assistant id
+          openai_assistant_id = assistantId
+          document.getElementById("assistantId").value = assistantId;
+
+          // create a new thread
+          openai_thread_id = await create_thread();
+          if (!openai_thread_id) {
+              alert("Error: Unable to create a new OpenAI thread");
+              return false;
+          }
+          // print thread id on the page
+          document.getElementById("assistantThreadId").value = openai_thread_id;
+
+          // setup event handler
+          openai_event_handler = new EventHandler(openai)
+          if (!openai_event_handler) {
+              alert("Error: Unable to create event handler");
+              return false;
+          }
+          openai_event_handler.on("event", openai_event_handler.onEvent.bind(openai_event_handler))
+          return true;
+      } else {
+          alert("Error: Assistant not found. Please check your OpenAI API key and assistant name");
+          return false;
+      }
+  }
+
+  // get assistant response based on user input
+  async function find_assistant(assistant_name) {
+      // sanity check openai connection
+      if (!openai) {
+          return null;
+      }
+
+      try {
+          // get a list of all assistants
+          const assistants_list = await openai.beta.assistants.list({order: "desc", limit: 20});
+
+          // iterate through assistants and find the one with the matching name
+          let assistant = assistants_list.data.find(a => a.name === assistant_name);
+
+          // return assistant ID if found, otherwise return null
+          return assistant ? assistant.id : null;
+      } catch (error) {
+          // return null in case of an error
+          return null;
+      }
+  }
+
+  // create a new thread
+  // returns thread id on success, null on failure
+  async function create_thread() {
+    // sanity check the assistant id
+    if (!openai_assistant_id) {
+        return null;
+    }
+
+    try {
+        // create a thread
+        const new_thread = await openai.beta.threads.create();
+        return new_thread ? new_thread.id : null;
+    } catch (error) {
+        return null;
+    }
+  }
+
+  // get assistant response based on user input
+  async function get_assistant_response(input) {
+      // sanity check the assistant id
+      if (!openai_assistant_id) {
+          return "get_assistant_response: assistant not found";
+      }
+      // sanity check thread
+      if (!openai_thread_id) {
+          return "get_assistant_response: thread not found";
+      }
+
+      // add a message to the thread
+      const message = await openai.beta.threads.messages.create(openai_thread_id, { role: "user", content: input });
+
+      // run the assistant
+      const stream = await openai.beta.threads.runs.stream(openai_thread_id, { assistant_id: openai_assistant_id, stream: true })
+      stream.on('event', (event) => openai_event_handler.emit("event", event))
+  }
+
+  // handle function call from assistant
+  function handle_function_call(name, args) {
+      add_text_to_debug("Function call: " + name + " with args: " + JSON.stringify(args));
+      // call the function
+      switch (name) {
+          case "get_vehicle_type":
+              // get the vehicle type (e.g. Copter, Plane, Rover, Boat, etc)
+              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
+              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.
+              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
+              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
+              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
+              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
+              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
+              return get_location_plus_dist_at_bearing(args);
+          case "get_parameter_description":
+              // Get vehicle parameter descriptions including description, units, min and max
+              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
+              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);
+              return "Unknown function: " + name;
+          case "get_current_datetime":
+              // Get the current date and time, e.g. 'Saturday, June 24, 2023 6:14:14 PM
+              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
+              return get_mode_mapping(args);
+          case "get_all_parameters":
+              // Get all available parameter names and values
+              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);
+              return "Unknown function: " + name;
+          case "get_available_mavlink_messages":
+              return get_available_mavlink_messages();
+          default:
+              add_text_to_debug("Unknown function: " + name);
+              return "Unknown function: " + name;
+      }
+  }
+
+    // function calls below here
+    // returns "Copter", "Plane", "Rover", "Boat", etc or "Unknown"
+    function get_vehicle_type() {
+
+        // get the latest HEARTBEAT message and perform a sanity check
+        let heartbeat_msg = mavlink_store.get_latest_message(0);
+        //add_text_to_debug("get_vehicle_type: got latest msg" + JSON.stringify(heartbeat_msg));
+        if (!heartbeat_msg || !heartbeat_msg.hasOwnProperty("type")) {
+            return "unknown because no HEARTBEAT message has been received from the vehicle";
+        }
+        let vehicle_type = heartbeat_msg["type"];
+
+        // get the vehicle type from the heartbeat message's type field
+        switch (vehicle_type) {
+            case mavlink20.MAV_TYPE_FIXED_WING:
+            case mavlink20.MAV_TYPE_VTOL_DUOROTOR:
+            case mavlink20.MAV_TYPE_VTOL_QUADROTOR:
+            case mavlink20.MAV_TYPE_VTOL_TILTROTOR:
+                return "Plane"
+            case mavlink20.MAV_TYPE_GROUND_ROVER:
+                return "Rover";
+            case mavlink20.MAV_TYPE_SURFACE_BOAT:
+                return "Boat";
+            case mavlink20.MAV_TYPE_SUBMARINE:
+                return "Sub";
+            case mavlink20.MAV_TYPE_QUADROTOR:
+            case mavlink20.MAV_TYPE_COAXIAL:
+            case mavlink20.MAV_TYPE_HEXAROTOR:
+            case mavlink20.MAV_TYPE_OCTOROTOR:
+            case mavlink20.MAV_TYPE_TRICOPTER:
+            case mavlink20.MAV_TYPE_DODECAROTOR:
+                return "Copter";
+            case mavlink20.MAV_TYPE_HELICOPTER:
+                return "Heli";
+            case mavlink20.MAV_TYPE_ANTENNA_TRACKER:
+                return "Tracker";
+            case mavlink20.MAV_TYPE_AIRSHIP:
+                return "Blimp";
+            default:
+                add_text_to_debug("get_vehicle_type: default, unknown");
+                return "unknown";
+        }
+
+        // if we got this far  we don't know the vehicle type
+        add_text_to_debug("get_vehicle_type: no match for type:" + hearbeat_msg.type);
+        return "unknown";
+    }
+
+    // get names of all available mavlink messages
+    function get_available_mavlink_messages() {
+        // get the available message names
+        let msg_names = mavlink_store.get_available_message_names();
+        if (!msg_names) {
+            return "No available messages";
+        }
+        return msg_names.join(", ");
+    }
+
+  // get the current time and date as a string. E.g. 'Saturday, June 24, 2023 6:14:14 PM'
+  function getFormattedDate() {
+      const options = {
+          weekday: 'long', 
+          year: 'numeric', 
+          month: 'long', 
+          day: 'numeric', 
+          hour: 'numeric', 
+          minute: 'numeric', 
+          second: 'numeric', 
+          hour12: true 
+      };
+      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()
+            this.client = client;
+        }
+
+        async onEvent(event) {
+            try {
+                // print status on html page
+                document.getElementById("assistantRunStatus").value = event.event;
+
+                // handle each event
+                switch (event.event) {
+                // retrieve events that are denoted with 'requires_action'
+                // since these will have our tool_calls
+                case "thread.run.requires_action":
+                    await this.handleRequiresAction(
+                        event.data,
+                        event.data.id,
+                        event.data.thread_id,
+                    )
+                    break;
+                case "thread.message.delta":
+                case "thread.run.step.delta":
+                    let delta_text = event.data.delta.content[0].text.value
+                    add_text_to_chat(delta_text, "assistant")
+                    break;
+
+                // events below can be ignored
+                case "thread.created":
+                case "thread.message.completed":
+                case "thread.run.created":
+                case "thread.run.queued":
+                case "thread.run.in_progress":
+                case "thread.run.completed":
+                case "thread.run.incomplete":
+                case "thread.run.failed":
+                case "thread.run.step.created":
+                case "thread.run.cancelling":
+                case "thread.run.step.in_progress":
+                case "thread.run.cancelled":
+                case "thread.run.expired":
+                case "thread.run.step.created":
+                case "thread.run.step.in_progress":
+                case "thread.run.step.completed":
+                case "thread.run.step.failed":
+                case "thread.run.step.cancelled":
+                case "thread.run.step.expired":
+                case "thread.message.created":
+                case "thread.message.in_progress":
+                case "thread.message.completed":
+                case "thread.message.incomplete":
+                case "error":
+                case "done":
+                    break;
+
+                // catch unhandled events
+                default:
+                    add_text_to_debug("Unhandled event: " + event.event)
+                    console.log(event)
+                }
+
+            } catch (error) {
+                console.error("Error handling event:", error)
+            }
+        }
+
+        // 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 {
+                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) {
+            try {
+                // use the submitToolOutputsStream helper
+                const stream = this.client.beta.threads.runs.submitToolOutputsStream(
+                    threadId,
+                    runId,
+                    { tool_outputs: toolOutputs },
+                )
+                for await (const event of stream) {
+                    this.emit("event", event)
+                }
+            } catch (error) {
+                console.error("Error submitting tool outputs:", error)
+            }
+        }
+    }
+</script>
+</body>
+</html>
diff --git a/Chat/index.html b/Chat/index.html
index 32d80283..df69f46e 100644
--- a/Chat/index.html
+++ b/Chat/index.html
@@ -64,7 +64,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
     <div class="input-container">
         <button id="sendButton">Rec</button>
         <input type="text" id="userInput" class="input-field" placeholder="Type a message...">
-        <button class="send-button" id="sendMessageButton" >Send</button>
+        <button class="send-button" onclick="send_message()">Send</button>
     </div>
   </div>
 
@@ -96,7 +96,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
   <!-- MAVLink connection button -->
   <div class="mavlink-connection-container">
       <label for="MAVLinkConnection">MAVLink Connect:</label>
-      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:8765" readonly>
+      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:8765">            <!-- MAVLink connection -->
       <button id="mavlink-connect-button">Connect</button>
   </div>
 
@@ -173,6 +173,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
             // set up event handlers
             mavlink_ws.onopen = function() {
                 mavlink_set_connect_state(true);
+                add_text_to_debug("WebSocket CONNECTED successfully!");
             };
             mavlink_ws.onclose = function() {
                 mavlink_set_connect_state(false);
@@ -181,99 +182,103 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
                 mavlink_disconnect();
             };
 
+            // Replace your onmessage handler with this for better debugging:
+            // mavlink_ws.onmessage = (msg) => {
+
+            //     if (MAVLink == null) {
+            //         return;
+            //     }
+
+            //     // Debug data type
+            //     // add_text_to_debug("⚡ Received data type: " + typeof(msg.data));
+            //     // add_text_to_debug("msg is: "+msg.data);
+                
+            //     // Handle different data types
+            //     let dataArray;
+            //     if (typeof msg.data === 'string') {
+            //         // add_text_to_debug("String data received - converting to bytes");
+            //         // dataArray = new TextEncoder().encode(msg.data);
+
+            //         for (const char of new Uint8Array(msg.data)) {
+            //             add_text_to_debug("1");
+            //             const mavlink_msg = MAVLink.parseChar(char)
+            //             add_text_to_debug("2");
+            //             if ((mavlink_msg != null) && (mavlink_msg._id != -1)) {
+            //                 // got a message with a known ID
+            //                 add_text_to_debug("3");
+            //                 mavlink_msg_handler(mavlink_msg);
+            //                 add_text_to_debug("yayyy");
+            //             }
+            //         }
+
+            //     } else if (msg.data instanceof ArrayBuffer) {
+            //         dataArray = new Uint8Array(msg.data);
+            //     } else if (msg.data instanceof Blob) {
+            //         add_text_to_debug("Blob data received - reading as ArrayBuffer");
+            //         // Need to read the Blob asynchronously
+            //         const reader = new FileReader();
+            //         reader.onload = function() {
+            //             const arrayBuffer = reader.result;
+            //             const bytes = new Uint8Array(arrayBuffer);
+            //             processMavlinkBytes(bytes);
+            //         };
+            //         reader.readAsArrayBuffer(msg.data);
+            //         return;
+            //     } else {
+            //         add_text_to_debug("❌ Unknown data type received");
+            //         return;
+            //     }
+                
+            //     // processMavlinkBytes(dataArray);
+            // };
 
-            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            // parse incoming message and forward
             mavlink_ws.onmessage = (msg) => {
-                // sanity check parser has been created
                 if (MAVLink == null) {
                     return;
                 }
-                // add_text_to_debug(msg.data);
-
-                const json_data = JSON.parse(msg.data);
-                // add_text_to_debug("Received: " + json_data.mavpackettype);
-                const mavlink_msg = createMavlinkMsgFromJson(json_data);
 
-                // parse message
-                if (mavlink_msg) {
-                    mavlink_msg_handler(mavlink_msg);
-                    // add_text_to_debug("done and dusted");
+                // Debug data type
+                // add_text_to_debug("Received data of type: " + typeof(msg.data));
+                
+                let dataArray;
+                if (typeof msg.data === 'string') {
+                    // Properly convert string to bytes
+                    // add_text_to_debug("Converting string data to bytes");
+                    const encoder = new TextEncoder();
+                    dataArray = encoder.encode(msg.data);
+                } else if (msg.data instanceof ArrayBuffer) {
+                    dataArray = new Uint8Array(msg.data);
+                } else if (msg.data instanceof Blob) {
+                    // Handle asynchronously
+                    const reader = new FileReader();
+                    reader.onload = function() {
+                        processMavlinkBytes(new Uint8Array(reader.result));
+                    };
+                    reader.readAsArrayBuffer(msg.data);
+                    return;
+                } else {
+                    add_text_to_debug("❌ Unknown data type received");
+                    return;
                 }
-                else add_text_to_debug("❌❌❌❌no msg");
                 
-            }
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-        }
-    }
+                // Process the bytes
+                processMavlinkBytes(dataArray);
+            };
 
-    // Add this function to convert JSON to MAVLink-compatible format
-    function createMavlinkMsgFromJson(json) {
-        if (!json || !json.mavpackettype) {
-            add_text_to_debug("❌ Invalid message format");
-            return null;
-        }
-        
-        try {
-            // Create a base object that preserves all original fields
-            const result = {
-                ...json,
-                // Add required fields for mavlink_store
-                _id: getMavlinkMessageId(json.mavpackettype),
-                _header: {
-                    srcSystem: 1,  // Default system ID
-                    srcComponent: 1  // Default component ID
+            function processMavlinkBytes(bytes) {
+                // add_text_to_debug("Processing " + bytes.length + " bytes");
+                for (const byte of bytes) {
+                    const mavlink_msg = MAVLink.parseChar(byte);
+                    if (mavlink_msg && mavlink_msg._id !== -1) {
+                        // add_text_to_debug("Parsed message ID: " + mavlink_msg._id);
+                        mavlink_msg_handler(mavlink_msg);
+                    }
                 }
-            };
-            
-            // Special handling for HEARTBEAT messages
-            if (json.mavpackettype === "HEARTBEAT") {
-                // add_text_to_debug("⭐ Received heartbeat message");
-                // Store directly for quick access
-                latest_heartbeat_message = result;
             }
-            
-            return result;
-        } catch (error) {
-            add_text_to_debug("❌ Error creating MAVLink message: " + error.message);
-            return null;
-        }
-    }
 
-    // Helper function to map common message types to IDs
-    function getMavlinkMessageId(msgType) {
-        if (msgType.toUpperCase() === "HEARTBEAT") {
-            return 0;  // Always use 0 for HEARTBEAT
         }
-        const messageMap = {
-            "HEARTBEAT": 0,
-            "heartbeat": 0,
-            "SYS_STATUS": 1,
-            "PARAM_VALUE": 22,
-            "GPS_RAW_INT": 24,
-            "ATTITUDE": 30,
-            "GLOBAL_POSITION_INT": 33,
-            "RC_CHANNELS_RAW": 35,
-            "SERVO_OUTPUT_RAW": 36,
-            "MISSION_ITEM": 39,
-            "MISSION_REQUEST": 40,
-            "MISSION_ACK": 47,
-            "GPS_GLOBAL_ORIGIN": 49,
-            "NAV_CONTROLLER_OUTPUT": 62,
-            "RC_CHANNELS": 65,
-            "VFR_HUD": 74,
-            "COMMAND_LONG": 76,
-            "COMMAND_ACK": 77,
-            "ATTITUDE_QUATERNION": 31,
-            "LOCAL_POSITION_NED": 32,
-            "POSITION_TARGET_LOCAL_NED": 85,
-            "POSITION_TARGET_GLOBAL_INT": 87,
-            "STATUSTEXT": 253
-        };
-        
-        return messageMap[msgType] || -1;  // Return -1 for unknown types
     }
+
     // disconnect from the vehicle
     function mavlink_disconnect() {
         if (mavlink_ws != null) {
@@ -290,27 +295,31 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
             return;
         }
 
+        // Store directly if this is a heartbeat message
+        if (msg._id === 0) { // HEARTBEAT
+            latest_heartbeat_message = msg;
+            add_text_to_debug("⭐ Stored heartbeat directly: type=" + msg.type);
+        }
 
-        // store the message in the message store
+        // Still store in mavlink_store for other functions
         mavlink_store.store_message(msg);
 
         switch (msg._id) {
             case 0: // HEARTBEAT
-                // alert("custom mode:" + msg.custom_mode);
-                // add_text_to_debug("HEARTBEAT message processed in switch statement!");
-                // alert("Got a heartbeat: " + JSON.stringify(msg));
+                //alert("custom mode:" + msg.custom_mode);
+                //alert("Got a heartbeat: " + JSON.stringify(msg));
                 break;
             case 1: // SYS_STATUS
-                // alert("Got a system status: " + JSON.stringify(msg));
+                //alert("Got a system status: " + JSON.stringify(msg));
                 break;
             case 24: // GPS_RAW_INT
                 //alert("Got a GPS raw int: " + JSON.stringify(msg));
                 break;
             case 30: // ATTITUDE
-                // alert("Got an attitude: " + JSON.stringify(msg));
+                //alert("Got an attitude: " + JSON.stringify(msg));
                 break;
             case 33: // GLOBAL_POSITION_INT
-                // alert("Got a global position int: " + JSON.stringify(msg));
+                //alert("Got a global position int: " + JSON.stringify(msg));
                 break;
             case 35: // HIGHRES_IMU
                 //alert("Got a high resolution IMU: " + JSON.stringify(msg));
@@ -325,7 +334,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
                 //alert("Got a status text: " + JSON.stringify(msg));
                 break;
             default:
-                // alert("Got a message id: " + JSON.stringify(msg));
+                //alert("Got a message id: " + JSON.stringify(msg));
                 break;
         }
     }
@@ -366,6 +375,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
         debugOutput.value += text + "\n";
         debugOutput.scrollTop = debugOutput.scrollHeight;
     }
+
 </script>
 
 <script type="module">
@@ -406,8 +416,6 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
           send_message();
       }
   })
-  // listener for send message button click
-  document.getElementById("sendMessageButton").addEventListener("click", send_message);
 
   // get openai API key (use this in API calls)
   function get_openai_api_key() {
@@ -466,11 +474,14 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
 
       // fetch response from assistant
       let response = await get_assistant_response(userInput);
-
+      
+      
       // display assistant response
       add_text_to_chat(response, "assistant");
   }
 
+  window.send_message = send_message;
+
   //
   // methods below here interact directly with the OpenAI API
   //
@@ -545,7 +556,6 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
       }
   }
 
-  // create a new thread
   // returns thread id on success, null on failure
   async function create_thread() {
     // sanity check the assistant id
@@ -578,7 +588,11 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
 
       // run the assistant
       const stream = await openai.beta.threads.runs.stream(openai_thread_id, { assistant_id: openai_assistant_id, stream: true })
-      stream.on('event', (event) => openai_event_handler.emit("event", event))
+      stream.on('event', (event) => {
+        //   add_text_to_debug("Event received: " + event.event);
+          openai_event_handler.emit("event", event);
+      });
+    //   stream.on('event', (event) => openai_event_handler.emit("event", event))
   }
 
   // handle function call from assistant
@@ -597,17 +611,16 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
               // fallthrough
           case "get_vehicle_location_and_yaw":
               // Get the vehicle's current location including latitude, longitude, altitude above sea level and altitude above home
-              return get_vehicle_location_and_yaw();
+              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();
           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
@@ -650,6 +663,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
 
     // function calls below here
     // returns "Copter", "Plane", "Rover", "Boat", etc or "Unknown"
+
     function get_vehicle_type() {
 
         // get the latest HEARTBEAT message and perform a sanity check
@@ -721,39 +735,54 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
       return new Date().toLocaleString('en-US', options);
   }
 
-  function get_vehicle_location_and_yaw() {
-    // Get the latest GLOBAL_POSITION_INT message
-    const position_msg = mavlink_store.get_latest_message(33);
-    add_text_to_debug(position_msg);
-    if (!position_msg) {
+  // Add this function alongside your other function implementations
+  function get_vehicle_state() {
+        // Get the latest HEARTBEAT message
+        let heartbeat_msg = mavlink_store.get_latest_message(0);
+        if (!heartbeat_msg) {
+            return JSON.stringify({
+                armed: false,
+                mode: 0
+            });
+        }
+
+
+        function get_vehicle_location_and_yaw() {
+            // Get the latest GLOBAL_POSITION_INT message
+            let position_msg = mavlink_store.get_latest_message(33);
+            if (!position_msg) {
+                return JSON.stringify({
+                    error: "No position information available"
+                });
+            }
+            
+            // Extract coordinates (convert from degE7 to decimal degrees)
+            const lat = position_msg.lat / 1e7;
+            const lon = position_msg.lon / 1e7;
+            const alt_msl = position_msg.alt / 1000;  // mm to meters
+            const alt_relative = position_msg.relative_alt / 1000;  // mm to meters
+            
+            return JSON.stringify({
+                latitude: lat,
+                longitude: lon,
+                altitude_msl: alt_msl,
+                altitude_relative: alt_relative,
+                heading: position_msg.hdg / 100  // centi-degrees to degrees
+            });
+        }
+        
+        // Get armed status
+        const armed = heartbeat_msg.base_mode & mavlink20.MAV_MODE_FLAG_SAFETY_ARMED ? true : false;
+        
+        // Get current mode
+        const mode_number = heartbeat_msg.custom_mode;
+        
         return JSON.stringify({
-            error: "No position information available"
+            armed: armed,
+            mode: mode_number
         });
     }
-    
-    // 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_msl: position_msg.alt / 1000.0,         // mm to meters
-        altitude_relative: 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);
-}
+
 
   class EventHandler extends EventEmitter {
         constructor(client) {

From fca61bdd53c79e9bda482a3cd7d4ca8d5b98fff2 Mon Sep 17 00:00:00 2001
From: codemaster1104 <akshatshrivastava1823@gmail.com>
Date: Mon, 11 Aug 2025 21:48:36 +0530
Subject: [PATCH 3/3] update2

---
 Chat/i2.html    | 1226 --------------------------------
 Chat/i3.html    | 1801 -----------------------------------------------
 Chat/index.html | 1251 +++++++++++++++++++++++++++-----
 3 files changed, 1080 insertions(+), 3198 deletions(-)
 delete mode 100644 Chat/i2.html
 delete mode 100644 Chat/i3.html

diff --git a/Chat/i2.html b/Chat/i2.html
deleted file mode 100644
index eb5edb2f..00000000
--- a/Chat/i2.html
+++ /dev/null
@@ -1,1226 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <title>Chat</title>
-  <link rel="icon" href="../images/AP_favicon.png">
-  <script type="text/javascript" src="MAVLink/mavlink.js"></script>
-</head>
-<table style="width:1200px">
-  <tr>
-    <td>
-      <a href="https://ardupilot.org"><img src="../images/ArduPilot.png"></a>
-    </td>
-    <td>
-      <a href="https://github.com/ArduPilot/WebTools"><img src="../images/github-mark.png" style="width:60px"></a><br>
-      <a href="https://github.com/ArduPilot/WebTools"><img src="../images/GitHub_Logo.png" style="width:60px"></a>
-    </td>
-  </tr>
-</table>
-
-<style>
-    body {
-        font-family: Arial, sans-serif;
-    }
-    .chat-container {
-        width: 400px;
-        border: 1px solid #ccc;
-        border-radius: 5px;
-        padding: 10px;
-        background-color: #f9f9f9;
-    }
-    .chat-box {
-        width: 100%;
-        height: 200px;
-        border: 1px solid #ccc;
-        background-color: white;
-        padding: 5px;
-        overflow-y: auto;
-    }
-    .user-text {
-        color: red;
-    }
-    .assistant-text {
-        color: black;
-    }
-    .input-container {
-        display: flex;
-        margin-top: 10px;
-    }
-    .input-field {
-        flex: 1;
-        padding: 5px;
-    }
-    .send-button {
-        margin-left: 5px;
-    }
-</style>
-
-<h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
-
-<body>
-  <div class="chat-container">
-    <div class="chat-box" id="chatBox"></div>
-    <div class="input-container">
-        <button id="sendButton">Rec</button>
-        <input type="text" id="userInput" class="input-field" placeholder="Type a message...">
-        <button class="send-button" id="sendMessageButton" >Send</button>
-    </div>
-  </div>
-
-  <!-- OpenAI API key input field -->
-  <div class="openaiapi-key-container">
-    <label for="openai_api_key">OpenAI API Key:</label>
-    <input type="password" id="openai_api_key" class="input-field">
-    <button onclick="toggle_openai_api_key_visibility()">👁️</button>
-  </div>
-
-  <!-- read-only input for Assistant ID -->
-  <div class="assistant-id-container">
-    <label for="assistantId">assistant id:</label>
-    <input type="text" id="assistantId" class="input-field" readonly>
-  </div>
-
-  <!-- read-only input for assistant thread id -->
-  <div class="assistant-thread-container">
-    <label for="assistantThreadId">thread id:</label>
-    <input type="text" id="assistantThreadId" class="input-field" readonly>
-  </div>
-
-  <!-- read-only input for Assistant status -->
-  <div class="assistant-run-status-container">
-    <label for="assistantRunStatus">run status:</label>
-    <input type="text" id="assistantRunStatus" class="input-field" readonly>
-  </div>
-
-  <!-- MAVLink connection button -->
-  <div class="mavlink-connection-container">
-      <label for="MAVLinkConnection">MAVLink Connect:</label>
-      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:8765" readonly>
-      <button id="mavlink-connect-button">Connect</button>
-  </div>
-
-  <!-- MAVLink arming button -->
-  <div class="mavlink-arm-container">
-      <label for="mavlink-arm-vehicle">Arm Vehicle</label>
-      <button id="mavlink-arm-button">Arm</button>
-  </div>
-
-  <!-- debug output text box -->
-  <div class="debug-output-container">
-      <textarea id="debugOutput" class="input-field" rows="10" readonly></textarea>
-  </div>
-
-  <!-- simple script functions local to this page -->
-  <script type="module">
-    // imports
-    import { mavlink_store } from './MAVLink/mavlink_store.js';
-
-    let latest_heartbeat_message = null;
-
-    // show/hide the OpenAI API key field
-    function toggle_openai_api_key_visibility() {
-        let openai_key_input = document.getElementById("openai_api_key");
-        openai_key_input.type = openai_key_input.type === "password" ? "text" : "password";
-    }
-
-    // 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_sysid = 254; // system id
-    let mavlink_compid = MAVLink20Processor.MAV_COMP_ID_MISSIONPLANNER; // component id
-    let MAVLink = new MAVLink20Processor(null, mavlink_sysid, mavlink_compid);
-
-    // toggle connection state (called by Connect/Disconnect button)
-    function mavlink_toggle_connect() {
-        if (is_connected) {
-            mavlink_disconnect();
-        } else {
-            mavlink_connect();
-        }
-    }
-
-    // attach event listener to the connect button
-    if (connect_button) {
-        connect_button.addEventListener("click", mavlink_toggle_connect);
-    }
-
-    // set the mavlink button connection state
-    function mavlink_set_connect_state(connected) {
-        is_connected = connected;
-        if (connected) {
-            connect_button.innerText = "Disconnect";
-        } else {
-            connect_button.innerText = "Connect";
-        }
-    }
-
-    // connect to the vehicle
-    function mavlink_connect() {
-        // check connection URL
-        let connect_url = document.getElementById("mavlink-connect-url").value;
-        if (!connect_url) {
-            alert("Error: WebSocket URL is empty");
-            return;
-        }
-
-        if (mavlink_ws == null) {
-            // create a new websocket connection
-            mavlink_ws = new WebSocket(connect_url);
-            mavlink_ws.binaryType = "arraybuffer"
-
-            // set up event handlers
-            mavlink_ws.onopen = function() {
-                mavlink_set_connect_state(true);
-            };
-            mavlink_ws.onclose = function() {
-                mavlink_set_connect_state(false);
-            };
-            mavlink_ws.onerror = function() {
-                mavlink_disconnect();
-            };
-
-
-            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-            // parse incoming message and forward
-            mavlink_ws.onmessage = (msg) => {
-                // sanity check parser has been created
-                if (MAVLink == null) {
-                    return;
-                }
-                // add_text_to_debug(msg.data);
-
-                const json_data = JSON.parse(msg.data);
-                // add_text_to_debug("Received: " + json_data.mavpackettype);
-                const mavlink_msg = createMavlinkMsgFromJson(json_data);
-
-                // parse message
-                if (mavlink_msg) {
-                    mavlink_msg_handler(mavlink_msg);
-                    // add_text_to_debug("done and dusted");
-                }
-                else add_text_to_debug("❌❌❌❌no msg");
-                
-            }
-            //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-        }
-    }
-
-    // Add this function to convert JSON to MAVLink-compatible format
-    function createMavlinkMsgFromJson(json) {
-        if (!json || !json.mavpackettype) {
-            add_text_to_debug("❌ Invalid message format");
-            return null;
-        }
-        
-        try {
-            // Create a base object that preserves all original fields
-            const result = {
-                ...json,
-                // Add required fields for mavlink_store
-                _id: getMavlinkMessageId(json.mavpackettype),
-                _header: {
-                    srcSystem: 1,  // Default system ID
-                    srcComponent: 1  // Default component ID
-                }
-            };
-            
-            // Special handling for HEARTBEAT messages
-            if (json.mavpackettype === "HEARTBEAT") {
-                // add_text_to_debug("⭐ Received heartbeat message");
-                // Store directly for quick access
-                latest_heartbeat_message = result;
-            }
-            
-            return result;
-        } catch (error) {
-            add_text_to_debug("❌ Error creating MAVLink message: " + error.message);
-            return null;
-        }
-    }
-
-    // Helper function to map common message types to IDs
-    function getMavlinkMessageId(msgType) {
-        if (msgType.toUpperCase() === "HEARTBEAT") {
-            return 0;  // Always use 0 for HEARTBEAT
-        }
-        const messageMap = {
-            "HEARTBEAT": 0,
-            "heartbeat": 0,
-            "SYS_STATUS": 1,
-            "PARAM_VALUE": 22,
-            "GPS_RAW_INT": 24,
-            "ATTITUDE": 30,
-            "GLOBAL_POSITION_INT": 33,
-            "RC_CHANNELS_RAW": 35,
-            "SERVO_OUTPUT_RAW": 36,
-            "MISSION_ITEM": 39,
-            "MISSION_REQUEST": 40,
-            "MISSION_ACK": 47,
-            "GPS_GLOBAL_ORIGIN": 49,
-            "NAV_CONTROLLER_OUTPUT": 62,
-            "RC_CHANNELS": 65,
-            "VFR_HUD": 74,
-            "COMMAND_LONG": 76,
-            "COMMAND_ACK": 77,
-            "ATTITUDE_QUATERNION": 31,
-            "LOCAL_POSITION_NED": 32,
-            "POSITION_TARGET_LOCAL_NED": 85,
-            "POSITION_TARGET_GLOBAL_INT": 87,
-            "STATUSTEXT": 253
-        };
-        
-        return messageMap[msgType] || -1;  // Return -1 for unknown types
-    }
-    // disconnect from the vehicle
-    function mavlink_disconnect() {
-        if (mavlink_ws != null) {
-            mavlink_ws.close();
-            mavlink_ws = null;
-        }
-    }
-
-    // mavlink message handler
-    function mavlink_msg_handler(msg) {
-
-        // sanity check msg
-        if (msg == null || msg._id == null) {
-            return;
-        }
-
-
-        // store the message in the message store
-        mavlink_store.store_message(msg);
-
-        switch (msg._id) {
-            case 0: // HEARTBEAT
-                // alert("custom mode:" + msg.custom_mode);
-                // add_text_to_debug("HEARTBEAT message processed in switch statement!");
-                // alert("Got a heartbeat: " + JSON.stringify(msg));
-                break;
-            case 1: // SYS_STATUS
-                // alert("Got a system status: " + JSON.stringify(msg));
-                break;
-            case 24: // GPS_RAW_INT
-                //alert("Got a GPS raw int: " + JSON.stringify(msg));
-                break;
-            case 30: // ATTITUDE
-                // alert("Got an attitude: " + JSON.stringify(msg));
-                break;
-            case 33: // GLOBAL_POSITION_INT
-                // alert("Got a global position int: " + JSON.stringify(msg));
-                break;
-            case 35: // HIGHRES_IMU
-                //alert("Got a high resolution IMU: " + JSON.stringify(msg));
-                break;
-            case 42: // NAMED_VALUE_FLOAT
-                //alert("Got a named value float: " + JSON.stringify(msg));
-                break;
-            case 74: // VFR_HUD
-                //alert("Got a VFR HUD: " + JSON.stringify(msg));
-                break;
-            case 253: // STATUSTEXT
-                //alert("Got a status text: " + JSON.stringify(msg));
-                break;
-
-            case 77: // COMMAND_ACK
-                add_text_to_debug("Got COMMAND_ACK: " + 
-                                "command=" + msg.command + 
-                                ", result=" + msg.result);
-                break;
-            default:
-                // alert("Got a message id: " + JSON.stringify(msg));
-                break;
-        }
-    }
-
-    // arm the vehicle
-    // function mavlink_arm_vehicle() {
-    //     if (mavlink_ws == null || mavlink_ws.readyState !== WebSocket.OPEN) {
-    //         alert("Please connect to the vehicle first");
-    //         return;
-    //     }
-    //     // construct the ARM command using COMMAND_LONG
-    //     let command_long_msg = new mavlink20.messages.command_long(
-    //         1,   // Target system ID
-    //         1,  // Target component ID
-    //         400,             // MAV_CMD_COMPONENT_ARM_DISARM (command ID 400)
-    //         1,               // Confirmation
-    //         1,               // Param1: 1 to arm, 0 to disarm
-    //         0, 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 ARM command via MAVLink");
-    //     } else {
-    //         alert("WebSocket is not open. Cannot send ARM command.");
-    //     }
-    // }
-
-    function mavlink_arm_vehicle() {
-        if (mavlink_ws == null || mavlink_ws.readyState !== WebSocket.OPEN) {
-            alert("Please connect to the vehicle first");
-            return;
-        }
-        
-        // Create JSON format COMMAND_LONG message for arming
-        const arm_command = {
-            "mavpackettype": "COMMAND_LONG",
-            "target_system": 1,
-            "target_component": 1,
-            "command": 400,  // MAV_CMD_COMPONENT_ARM_DISARM
-            "confirmation": 1,
-            "param1": 1,     // 1 to arm, 0 to disarm
-            "param2": 0,
-            "param3": 0,
-            "param4": 0,
-            "param5": 0,
-            "param6": 0,
-            "param7": 0
-        };
-        
-        // Send as JSON string
-        mavlink_ws.send(JSON.stringify(arm_command));
-        add_text_to_debug("Sent ARM command via MAVLink (JSON format)");
-        
-        // Listen for COMMAND_ACK in your message handler
-        add_text_to_debug("Waiting for acknowledgment...");
-    }
-    // attach event listener to the arm button
-    document.getElementById("mavlink-arm-button").addEventListener("click", mavlink_arm_vehicle);
-
-    // 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;
-    }
-</script>
-
-<script type="module">
-  // error handling
-  window.onerror = function(msg, url, linenumber) {
-      alert('Sorry, something went wrong.\n\n' + 
-            'Please try a hard reload of this page to clear its cache.\n\n' +
-            'If the error persists open an issue on the GitHub repo.\n' +
-            'Include a copy of the log and the following error message:\n\n' +
-            msg + '\n' +
-            'URL: '+ url +'\n' +
-            'Line Number: '+ linenumber)
-      return false
-  }
-  window.addEventListener('unhandledrejection', function (e) {
-      throw new Error(e.reason.stack)
-  })
-
-  // imports
-  import OpenAI from 'https://cdn.jsdelivr.net/npm/openai@4.85.4/+esm'
-  import EventEmitter from 'https://cdn.jsdelivr.net/npm/eventemitter3@5.0.1/+esm'
-  import { mavlink_store } from './MAVLink/mavlink_store.js';
-
-  // constants
-  const OPENAI_API_KEY = ""; // replace with your OpenAI API key
-  const OPENAI_MODEL = "gpt-4o"
-  const OPENAI_ASSISTANT_NAME = "ArduPilot Vehicle Control via MAVLink"
-
-  // global variables
-  let openai = null
-  let openai_assistant_id = null
-  let openai_thread_id = null
-  let openai_event_handler = null
-
-  // chat listener for user input and enter key
-  document.getElementById("userInput").addEventListener("keypress", function(event) {
-      if (event.key === "Enter") {
-          send_message();
-      }
-  })
-  // listener for send message button click
-  document.getElementById("sendMessageButton").addEventListener("click", send_message);
-
-  // get openai API key (use this in API calls)
-  function get_openai_api_key() {
-      if (OPENAI_API_KEY.length > 0) {
-          return OPENAI_API_KEY;
-      }
-      return document.getElementById("openai_api_key").value.trim();
-  }
-
-  // check connection
-  check_connection();
-
-  // add text to chat box
-  function add_text_to_chat(text, role = "assistant") {
-      let div_class = role === "assistant" ? "assistant-text" : "user-text";
-      let chatBox = document.getElementById("chatBox");
-
-      if (role === "assistant") {
-          // try to find the last assistant message and append to it
-          let last_message = chatBox.querySelector(`.${div_class}:last-of-type`);
-          if (last_message) {
-              last_message.textContent += text;
-              chatBox.scrollTop = chatBox.scrollHeight;
-              return;
-          }
-      }
-
-      // create a new message div if no previous assistant message exists
-      let message_div = document.createElement("div");
-      message_div.className = div_class;
-      message_div.textContent = text;
-      chatBox.appendChild(message_div);
-      chatBox.scrollTop = chatBox.scrollHeight;
-  }
-
-  // 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;
-  }
-
-  // send message to AI assistant, get response and place in chat box text area
-  async function send_message() {
-      // check connection to OpenAI
-      if (!(await check_connection())) {
-          return;
-      }
-
-      let userInput = document.getElementById("userInput").value;
-      if (!userInput.trim()) return;
-
-      // display user input and clear input field
-      add_text_to_chat(userInput, "user");
-      document.getElementById("userInput").value = "";
-
-      // fetch response from assistant
-      let response = await get_assistant_response(userInput);
-
-      // display assistant response
-      add_text_to_chat(response, "assistant");
-  }
-
-  //
-  // methods below here interact directly with the OpenAI API
-  //
-
-  // check connection to OpenAI API and return true on succes, false on failure
-  async function check_connection() {
-      // check openai API key
-      if (!get_openai_api_key()) {
-          return false;
-      }
-      // check openai connection
-      if (!openai) {
-          openai = new OpenAI({apiKey: get_openai_api_key(), dangerouslyAllowBrowser: true});
-          if (!openai) {
-              return false;
-          }
-      }
-
-      // return immediately if assistant id has already been found
-      if (openai_assistant_id) {
-          return true
-      }
-
-      let assistantId = await find_assistant(OPENAI_ASSISTANT_NAME);
-      if (assistantId) {
-          // store assistant id
-          openai_assistant_id = assistantId
-          document.getElementById("assistantId").value = assistantId;
-
-          // create a new thread
-          openai_thread_id = await create_thread();
-          if (!openai_thread_id) {
-              alert("Error: Unable to create a new OpenAI thread");
-              return false;
-          }
-          // print thread id on the page
-          document.getElementById("assistantThreadId").value = openai_thread_id;
-
-          // setup event handler
-          openai_event_handler = new EventHandler(openai)
-          if (!openai_event_handler) {
-              alert("Error: Unable to create event handler");
-              return false;
-          }
-          openai_event_handler.on("event", openai_event_handler.onEvent.bind(openai_event_handler))
-          return true;
-      } else {
-          alert("Error: Assistant not found. Please check your OpenAI API key and assistant name");
-          return false;
-      }
-  }
-
-  // get assistant response based on user input
-  async function find_assistant(assistant_name) {
-      // sanity check openai connection
-      if (!openai) {
-          return null;
-      }
-
-      try {
-          // get a list of all assistants
-          const assistants_list = await openai.beta.assistants.list({order: "desc", limit: 20});
-
-          // iterate through assistants and find the one with the matching name
-          let assistant = assistants_list.data.find(a => a.name === assistant_name);
-
-          // return assistant ID if found, otherwise return null
-          return assistant ? assistant.id : null;
-      } catch (error) {
-          // return null in case of an error
-          return null;
-      }
-  }
-
-  // create a new thread
-  // returns thread id on success, null on failure
-  async function create_thread() {
-    // sanity check the assistant id
-    if (!openai_assistant_id) {
-        return null;
-    }
-
-    try {
-        // create a thread
-        const new_thread = await openai.beta.threads.create();
-        return new_thread ? new_thread.id : null;
-    } catch (error) {
-        return null;
-    }
-  }
-
-  // get assistant response based on user input
-  async function get_assistant_response(input) {
-      // sanity check the assistant id
-      if (!openai_assistant_id) {
-          return "get_assistant_response: assistant not found";
-      }
-      // sanity check thread
-      if (!openai_thread_id) {
-          return "get_assistant_response: thread not found";
-      }
-
-      // add a message to the thread
-      const message = await openai.beta.threads.messages.create(openai_thread_id, { role: "user", content: input });
-
-      // run the assistant
-      const stream = await openai.beta.threads.runs.stream(openai_thread_id, { assistant_id: openai_assistant_id, stream: true })
-      stream.on('event', (event) => openai_event_handler.emit("event", event))
-  }
-
-  // handle function call from assistant
-  function handle_function_call(name, args) {
-      add_text_to_debug("Function call: " + name + " with args: " + JSON.stringify(args));
-      // call the function
-      switch (name) {
-          case "get_vehicle_type":
-              // get the vehicle type (e.g. Copter, Plane, Rover, Boat, etc)
-              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
-              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
-          case "get_vehicle_location_and_yaw":
-              // Get the vehicle's current location including latitude, longitude, altitude above sea level and altitude above home
-              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
-              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();
-          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
-              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
-          case "get_parameter_description":
-              // Get vehicle parameter descriptions including description, units, min and max
-              // fallthrough
-          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
-          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);
-              return "Unknown function: " + name;
-          case "get_current_datetime":
-              // Get the current date and time, e.g. 'Saturday, June 24, 2023 6:14:14 PM
-              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
-              return get_mode_mapping(args);
-          case "get_all_parameters":
-              // Get all available parameter names and values
-              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);
-              return "Unknown function: " + name;
-          case "get_available_mavlink_messages":
-              return get_available_mavlink_messages();
-          default:
-              add_text_to_debug("Unknown function: " + name);
-              return "Unknown function: " + name;
-      }
-  }
-
-    // function calls below here
-    // returns "Copter", "Plane", "Rover", "Boat", etc or "Unknown"
-    function get_vehicle_type() {
-
-        // get the latest HEARTBEAT message and perform a sanity check
-        let heartbeat_msg = mavlink_store.get_latest_message(0);
-        //add_text_to_debug("get_vehicle_type: got latest msg" + JSON.stringify(heartbeat_msg));
-        if (!heartbeat_msg || !heartbeat_msg.hasOwnProperty("type")) {
-            return "unknown because no HEARTBEAT message has been received from the vehicle";
-        }
-        let vehicle_type = heartbeat_msg["type"];
-
-        // get the vehicle type from the heartbeat message's type field
-        switch (vehicle_type) {
-            case mavlink20.MAV_TYPE_FIXED_WING:
-            case mavlink20.MAV_TYPE_VTOL_DUOROTOR:
-            case mavlink20.MAV_TYPE_VTOL_QUADROTOR:
-            case mavlink20.MAV_TYPE_VTOL_TILTROTOR:
-                return "Plane"
-            case mavlink20.MAV_TYPE_GROUND_ROVER:
-                return "Rover";
-            case mavlink20.MAV_TYPE_SURFACE_BOAT:
-                return "Boat";
-            case mavlink20.MAV_TYPE_SUBMARINE:
-                return "Sub";
-            case mavlink20.MAV_TYPE_QUADROTOR:
-            case mavlink20.MAV_TYPE_COAXIAL:
-            case mavlink20.MAV_TYPE_HEXAROTOR:
-            case mavlink20.MAV_TYPE_OCTOROTOR:
-            case mavlink20.MAV_TYPE_TRICOPTER:
-            case mavlink20.MAV_TYPE_DODECAROTOR:
-                return "Copter";
-            case mavlink20.MAV_TYPE_HELICOPTER:
-                return "Heli";
-            case mavlink20.MAV_TYPE_ANTENNA_TRACKER:
-                return "Tracker";
-            case mavlink20.MAV_TYPE_AIRSHIP:
-                return "Blimp";
-            default:
-                add_text_to_debug("get_vehicle_type: default, unknown");
-                return "unknown";
-        }
-
-        // if we got this far  we don't know the vehicle type
-        add_text_to_debug("get_vehicle_type: no match for type:" + hearbeat_msg.type);
-        return "unknown";
-    }
-
-    // get names of all available mavlink messages
-    function get_available_mavlink_messages() {
-        // get the available message names
-        let msg_names = mavlink_store.get_available_message_names();
-        if (!msg_names) {
-            return "No available messages";
-        }
-        return msg_names.join(", ");
-    }
-
-  // get the current time and date as a string. E.g. 'Saturday, June 24, 2023 6:14:14 PM'
-  function getFormattedDate() {
-      const options = {
-          weekday: 'long', 
-          year: 'numeric', 
-          month: 'long', 
-          day: 'numeric', 
-          hour: 'numeric', 
-          minute: 'numeric', 
-          second: 'numeric', 
-          hour12: true 
-      };
-      return new Date().toLocaleString('en-US', options);
-  }
-
-  function get_vehicle_location_and_yaw() {
-    // Get the latest GLOBAL_POSITION_INT message
-    const position_msg = mavlink_store.get_latest_message(33);
-    add_text_to_debug(position_msg);
-    if (!position_msg) {
-        return JSON.stringify({
-            error: "No position information available"
-        });
-    }
-    
-    // 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_msl: position_msg.alt / 1000.0,         // mm to meters
-        altitude_relative: 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);
-}
-
-function get_all_parameters() {
-    // Get all PARAM_VALUE messages from the mavlink store
-    // First check if any parameters are available
-    let 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 by iterating through stored messages
-    // This is a simplification - in a real system you'd have a parameter cache
-    let param_list = {};
-    
-    // Get all available systems and components
-    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 there are any PARAM_VALUE messages for this system/component
-            if (mavlink_store.store[sysid][compid][22]) {
-                // For each parameter, add it to our list
-                // Note: This only gets the latest parameter value
-                const param = mavlink_store.store[sysid][compid][22];
-                if (param.param_id) {
-                    param_list[param.param_id] = param.param_value;
-                }
-            }
-        }
-    }
-    
-    // If no parameters were found, return an error
-    if (Object.keys(param_list).length === 0) {
-        return JSON.stringify({
-            error: "No parameters found in MAVLink store"
-        });
-    }
-    
-    // Return the parameter list as a 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" });
-        }
-    }
-    
-    const param_name = args.name;
-    if (!param_name) {
-        return JSON.stringify({ error: "Parameter name not specified" });
-    }
-    
-    // Check if we have any parameters
-    let 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." 
-        });
-    }
-    
-    // Check if it's a regex pattern
-    const is_regex_pattern = /[.*+?^${}()|[\]\\]/.test(param_name);
-    
-    if (is_regex_pattern) {
-        // For regex matches, we need to check all stored parameters
-        try {
-            const regex = new RegExp(param_name);
-            const allParamsStr = get_all_parameters();
-            const allParams = JSON.parse(allParamsStr);
-            
-            if (allParams.error) {
-                return JSON.stringify({ error: allParams.error });
-            }
-            
-            // Filter parameters by regex
-            const matches = {};
-            for (const [name, value] of Object.entries(allParams)) {
-                if (regex.test(name)) {
-                    matches[name] = value;
-                }
-            }
-            
-            if (Object.keys(matches).length === 0) {
-                return JSON.stringify({ error: "No parameters match pattern: " + param_name });
-            }
-            
-            return JSON.stringify(matches);
-        } catch (error) {
-            return JSON.stringify({ error: "Error processing regex: " + error.message });
-        }
-    } else {
-        // For direct parameter name matching
-        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) {
-                if (mavlink_store.store[sysid][compid][22]) {
-                    const param = mavlink_store.store[sysid][compid][22];
-                    if (param.param_id === param_name) {
-                        const result = {};
-                        result[param_name] = param.param_value;
-                        return JSON.stringify(result);
-                    }
-                }
-            }
-        }
-        
-        return JSON.stringify({ error: "Parameter not found: " + param_name });
-    }
-}
-
-function get_vehicle_state() {
-    // Get the latest HEARTBEAT message
-    let heartbeat_msg = mavlink_store.get_latest_message(0);
-    if (!heartbeat_msg) {
-        return JSON.stringify({
-            armed: false,
-            mode: 0,
-            error: "No HEARTBEAT message received"
-        });
-    }
-    
-    // Extract armed status (base_mode bit 7 is the armed flag)
-    // In MAVLink, the armed status is in bit 7 (128) of the base_mode field
-    const base_mode = heartbeat_msg.base_mode || 0;
-    const custom_mode = heartbeat_msg.custom_mode || 0;
-    const armed = (base_mode & 128) !== 0;  // Check if bit 7 is set
-    
-    return JSON.stringify({
-        armed: armed,
-        mode: custom_mode
-    });
-}
-
-function get_mode_mapping(args) {
-    // Parse arguments if string
-    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?.toUpperCase();
-    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,
-            "FLOWHOLD": 22,
-            "FOLLOW": 23,
-            "ZIGZAG": 24,
-            "SYSTEMID": 25,
-            "AUTOROTATE": 26
-        },
-        "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,
-            "AVOID_ADSB": 14,
-            "GUIDED": 15,
-            "INITIALIZING": 16,
-            "QSTABILIZE": 17,
-            "QHOVER": 18,
-            "QLOITER": 19,
-            "QLAND": 20,
-            "QRTL": 21,
-            "QAUTOTUNE": 22,
-            "QACRO": 23
-        },
-        "Rover": {
-            "MANUAL": 0,
-            "ACRO": 1,
-            "STEERING": 3,
-            "HOLD": 4,
-            "LOITER": 5,
-            "FOLLOW": 6,
-            "SIMPLE": 7,
-            "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 send_mavlink_command_int(args) {
-    // Parse arguments if needed
-    if (typeof args === 'string') {
-        try {
-            args = JSON.parse(args);
-        } catch (e) {
-            return JSON.stringify({ error: "Invalid arguments format" });
-        }
-    }
-    
-    // Validate required arguments
-    if (!args.command) {
-        return JSON.stringify({ error: "command_int not sent. command field required" });
-    }
-    
-    // Check websocket connection
-    if (mavlink_ws == null || mavlink_ws.readyState !== WebSocket.OPEN) {
-        return JSON.stringify({ error: "WebSocket not connected. Please connect to vehicle first." });
-    }
-    
-    // Set default values for optional arguments
-    const target_system = args.target_system || 1;
-    const target_component = args.target_component || 1;
-    const frame = args.frame || 0;
-    const command = args.command;
-    const current = args.current || 0;
-    const autocontinue = args.autocontinue || 0;
-    const param1 = args.param1 || 0;
-    const param2 = args.param2 || 0;
-    const param3 = args.param3 || 0;
-    const param4 = args.param4 || 0;
-    const x = args.x || 0;
-    const y = args.y || 0;
-    const z = args.z || 0;
-    
-    // Specific command validations
-    if (command === 22 && z === 0) { // MAV_CMD_NAV_TAKEOFF = 22
-        return JSON.stringify({ error: "command_int not sent. MAV_CMD_NAV_TAKEOFF requires alt in z field" });
-    }
-    
-    // Create command_int message
-    const command_int_msg = {
-        "mavpackettype": "COMMAND_INT",
-        "target_system": target_system,
-        "target_component": target_component,
-        "frame": frame,
-        "command": command,
-        "current": current,
-        "autocontinue": autocontinue,
-        "param1": param1,
-        "param2": param2,
-        "param3": param3,
-        "param4": param4,
-        "x": x,
-        "y": y,
-        "z": z
-    };
-    
-    // Send command
-    add_text_to_debug("Sending COMMAND_INT: " + JSON.stringify(command_int_msg));
-    mavlink_ws.send(JSON.stringify(command_int_msg));
-    
-    // In a more sophisticated implementation, we would wait for the COMMAND_ACK
-    // This simplified version just returns that the command was sent
-    return JSON.stringify({
-        result: "command_int sent, check debug output for acknowledgment"
-    });
-}
-
-  class EventHandler extends EventEmitter {
-        constructor(client) {
-            super()
-            this.client = client;
-        }
-
-        async onEvent(event) {
-            try {
-                // print status on html page
-                document.getElementById("assistantRunStatus").value = event.event;
-
-                // handle each event
-                switch (event.event) {
-                // retrieve events that are denoted with 'requires_action'
-                // since these will have our tool_calls
-                case "thread.run.requires_action":
-                    await this.handleRequiresAction(
-                        event.data,
-                        event.data.id,
-                        event.data.thread_id,
-                    )
-                    break;
-                case "thread.message.delta":
-                case "thread.run.step.delta":
-                    let delta_text = event.data.delta.content[0].text.value
-                    add_text_to_chat(delta_text, "assistant")
-                    break;
-
-                // events below can be ignored
-                case "thread.created":
-                case "thread.message.completed":
-                case "thread.run.created":
-                case "thread.run.queued":
-                case "thread.run.in_progress":
-                case "thread.run.completed":
-                case "thread.run.incomplete":
-                case "thread.run.failed":
-                case "thread.run.step.created":
-                case "thread.run.cancelling":
-                case "thread.run.step.in_progress":
-                case "thread.run.cancelled":
-                case "thread.run.expired":
-                case "thread.run.step.created":
-                case "thread.run.step.in_progress":
-                case "thread.run.step.completed":
-                case "thread.run.step.failed":
-                case "thread.run.step.cancelled":
-                case "thread.run.step.expired":
-                case "thread.message.created":
-                case "thread.message.in_progress":
-                case "thread.message.completed":
-                case "thread.message.incomplete":
-                case "error":
-                case "done":
-                    break;
-
-                // catch unhandled events
-                default:
-                    add_text_to_debug("Unhandled event: " + event.event)
-                    console.log(event)
-                }
-
-            } catch (error) {
-                console.error("Error handling event:", error)
-            }
-        }
-
-        // 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)
-                    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)
-            }
-        }
-
-        // return function call results to the assistant
-        async submitToolOutputs(toolOutputs, runId, threadId) {
-            try {
-                // use the submitToolOutputsStream helper
-                const stream = this.client.beta.threads.runs.submitToolOutputsStream(
-                    threadId,
-                    runId,
-                    { tool_outputs: toolOutputs },
-                )
-                for await (const event of stream) {
-                    this.emit("event", event)
-                }
-            } catch (error) {
-                console.error("Error submitting tool outputs:", error)
-            }
-        }
-    }
-</script>
-</body>
-</html>
\ No newline at end of file
diff --git a/Chat/i3.html b/Chat/i3.html
deleted file mode 100644
index 0c3b68e0..00000000
--- a/Chat/i3.html
+++ /dev/null
@@ -1,1801 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="utf-8" />
-  <title>Chat</title>
-  <link rel="icon" href="../images/AP_favicon.png">
-  <script type="text/javascript" src="MAVLink/mavlink.js"></script>
-</head>
-<table style="width:1200px">
-  <tr>
-    <td>
-      <a href="https://ardupilot.org"><img src="../images/ArduPilot.png"></a>
-    </td>
-    <td>
-      <a href="https://github.com/ArduPilot/WebTools"><img src="../images/github-mark.png" style="width:60px"></a><br>
-      <a href="https://github.com/ArduPilot/WebTools"><img src="../images/GitHub_Logo.png" style="width:60px"></a>
-    </td>
-  </tr>
-</table>
-
-<style>
-    body {
-        font-family: Arial, sans-serif;
-    }
-    .chat-container {
-        width: 400px;
-        border: 1px solid #ccc;
-        border-radius: 5px;
-        padding: 10px;
-        background-color: #f9f9f9;
-    }
-    .chat-box {
-        width: 100%;
-        height: 200px;
-        border: 1px solid #ccc;
-        background-color: white;
-        padding: 5px;
-        overflow-y: auto;
-    }
-    .user-text {
-        color: red;
-    }
-    .assistant-text {
-        color: black;
-    }
-    .input-container {
-        display: flex;
-        margin-top: 10px;
-    }
-    .input-field {
-        flex: 1;
-        padding: 5px;
-    }
-    .send-button {
-        margin-left: 5px;
-    }
-</style>
-
-<h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
-
-<body>
-  <div class="chat-container">
-    <div class="chat-box" id="chatBox"></div>
-    <div class="input-container">
-        <button id="sendButton">Rec</button>
-        <input type="text" id="userInput" class="input-field" placeholder="Type a message...">
-        <button class="send-button" id="sendMessageButton" >Send</button>
-    </div>
-  </div>
-
-  <!-- OpenAI API key input field -->
-  <div class="openaiapi-key-container">
-    <label for="openai_api_key">OpenAI API Key:</label>
-    <input type="password" id="openai_api_key" class="input-field">
-    <button onclick="toggle_openai_api_key_visibility()">👁️</button>
-  </div>
-
-  <!-- read-only input for Assistant ID -->
-  <div class="assistant-id-container">
-    <label for="assistantId">assistant id:</label>
-    <input type="text" id="assistantId" class="input-field" readonly>
-  </div>
-
-  <!-- read-only input for assistant thread id -->
-  <div class="assistant-thread-container">
-    <label for="assistantThreadId">thread id:</label>
-    <input type="text" id="assistantThreadId" class="input-field" readonly>
-  </div>
-
-  <!-- read-only input for Assistant status -->
-  <div class="assistant-run-status-container">
-    <label for="assistantRunStatus">run status:</label>
-    <input type="text" id="assistantRunStatus" class="input-field" readonly>
-  </div>
-
-  <!-- MAVLink connection button -->
-  <div class="mavlink-connection-container">
-      <label for="MAVLinkConnection">MAVLink Connect:</label>
-      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:56781" readonly>
-      <button id="mavlink-connect-button">Connect</button>
-  </div>
-
-  <!-- MAVLink arming button -->
-  <div class="mavlink-arm-container">
-      <label for="mavlink-arm-vehicle">Arm Vehicle</label>
-      <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>
-  </div>
-
-  <!-- simple script functions local to this page -->
-  <script type="module">
-    // imports
-    import { mavlink_store } from './MAVLink/mavlink_store.js';
-
-    // show/hide the OpenAI API key field
-    function toggle_openai_api_key_visibility() {
-        let openai_key_input = document.getElementById("openai_api_key");
-        openai_key_input.type = openai_key_input.type === "password" ? "text" : "password";
-    }
-
-    // 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_sysid = 254; // system id
-    let mavlink_compid = MAVLink20Processor.MAV_COMP_ID_MISSIONPLANNER; // component id
-    // 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() {
-        if (is_connected) {
-            mavlink_disconnect();
-        } else {
-            mavlink_connect();
-        }
-    }
-
-    // attach event listener to the connect button
-    if (connect_button) {
-        connect_button.addEventListener("click", mavlink_toggle_connect);
-    }
-
-    // set the mavlink button connection state
-    function mavlink_set_connect_state(connected) {
-        is_connected = connected;
-        if (connected) {
-            connect_button.innerText = "Disconnect";
-        } else {
-            connect_button.innerText = "Connect";
-        }
-    }
-
-    // connect to the vehicle
-    function mavlink_connect() {
-        // check connection URL
-        let connect_url = document.getElementById("mavlink-connect-url").value;
-        if (!connect_url) {
-            alert("Error: WebSocket URL is empty");
-            return;
-        }
-
-        if (mavlink_ws == null) {
-            // create a new websocket connection
-            mavlink_ws = new WebSocket(connect_url);
-            mavlink_ws.binaryType = "arraybuffer"
-
-            // set up event handlers
-            mavlink_ws.onopen = function() {
-                mavlink_set_connect_state(true);
-            };
-            mavlink_ws.onclose = function() {
-                mavlink_set_connect_state(false);
-            };
-            mavlink_ws.onerror = function() {
-                mavlink_disconnect();
-            };
-
-            // parse incoming message and forward
-            mavlink_ws.onmessage = (msg) => {
-                // sanity check parser has been created
-                if (MAVLink == null) {
-                    return;
-                }
-                // parse message
-                for (const char of new Uint8Array(msg.data)) {
-                    const mavlink_msg = MAVLink.parseChar(char)
-                    if ((mavlink_msg != null) && (mavlink_msg._id != -1)) {
-                        // got a message with a known ID
-                        mavlink_msg_handler(mavlink_msg);
-                    }
-                }
-            }
-        }
-    }
-
-    // disconnect from the vehicle
-    function mavlink_disconnect() {
-        if (mavlink_ws != null) {
-            mavlink_ws.close();
-            mavlink_ws = null;
-        }
-    }
-
-    // mavlink message handler
-    function mavlink_msg_handler(msg) {
-
-        // sanity check msg
-        if (msg == null || msg._id == null) {
-            return;
-        }
-
-        // store the message in the message store
-        mavlink_store.store_message(msg);
-
-        switch (msg._id) {
-            case 0: // HEARTBEAT
-                //alert("custom mode:" + msg.custom_mode);
-                //alert("Got a heartbeat: " + JSON.stringify(msg));
-                break;
-            case 1: // SYS_STATUS
-                //alert("Got a system status: " + JSON.stringify(msg));
-                break;
-            case 24: // GPS_RAW_INT
-                //alert("Got a GPS raw int: " + JSON.stringify(msg));
-                break;
-            case 30: // ATTITUDE
-                //alert("Got an attitude: " + JSON.stringify(msg));
-                break;
-            case 33: // GLOBAL_POSITION_INT
-                //alert("Got a global position int: " + JSON.stringify(msg));
-                break;
-            case 35: // HIGHRES_IMU
-                //alert("Got a high resolution IMU: " + JSON.stringify(msg));
-                break;
-            case 42: // NAMED_VALUE_FLOAT
-                //alert("Got a named value float: " + JSON.stringify(msg));
-                break;
-            case 74: // VFR_HUD
-                //alert("Got a VFR HUD: " + JSON.stringify(msg));
-                break;
-            case 253: // STATUSTEXT
-                //alert("Got a status text: " + JSON.stringify(msg));
-                break;
-            default:
-                //alert("Got a message id: " + JSON.stringify(msg));
-                break;
-        }
-    }
-
-    // arm the vehicle
-    function mavlink_arm_vehicle() {
-        if (mavlink_ws == null || mavlink_ws.readyState !== WebSocket.OPEN) {
-            alert("Please connect to the vehicle first");
-            return;
-        }
-        // construct the ARM command using COMMAND_LONG
-        let command_long_msg = new mavlink20.messages.command_long(
-            1,   // Target system ID
-            1,  // Target component ID
-            400,             // MAV_CMD_COMPONENT_ARM_DISARM (command ID 400)
-            1,               // Confirmation
-            1,               // Param1: 1 to arm, 0 to disarm
-            0, 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 ARM command via MAVLink");
-        } else {
-            alert("WebSocket is not open. Cannot send ARM command.");
-        }
-    }
-    // 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">
-  // error handling
-  window.onerror = function(msg, url, linenumber) {
-      alert('Sorry, something went wrong.\n\n' + 
-            'Please try a hard reload of this page to clear its cache.\n\n' +
-            'If the error persists open an issue on the GitHub repo.\n' +
-            'Include a copy of the log and the following error message:\n\n' +
-            msg + '\n' +
-            'URL: '+ url +'\n' +
-            'Line Number: '+ linenumber)
-      return false
-  }
-  window.addEventListener('unhandledrejection', function (e) {
-      throw new Error(e.reason.stack)
-  })
-
-  // imports
-  import OpenAI from 'https://cdn.jsdelivr.net/npm/openai@4.85.4/+esm'
-  import EventEmitter from 'https://cdn.jsdelivr.net/npm/eventemitter3@5.0.1/+esm'
-  import { mavlink_store } from './MAVLink/mavlink_store.js';
-
-  // constants
-  const OPENAI_API_KEY = ""; // replace with your OpenAI API key
-  const OPENAI_MODEL = "gpt-4o"
-  const OPENAI_ASSISTANT_NAME = "ArduPilot Vehicle Control via MAVLink"
-
-  // global variables
-  let openai = null
-  let openai_assistant_id = null
-  let openai_thread_id = null
-  let openai_event_handler = null
-
-  // chat listener for user input and enter key
-  document.getElementById("userInput").addEventListener("keypress", function(event) {
-      if (event.key === "Enter") {
-          send_message();
-      }
-  })
-  // listener for send message button click
-  document.getElementById("sendMessageButton").addEventListener("click", send_message);
-
-  // get openai API key (use this in API calls)
-  function get_openai_api_key() {
-      if (OPENAI_API_KEY.length > 0) {
-          return OPENAI_API_KEY;
-      }
-      return document.getElementById("openai_api_key").value.trim();
-  }
-
-  // check connection
-  check_connection();
-
-  // add text to chat box
-  function add_text_to_chat(text, role = "assistant") {
-      let div_class = role === "assistant" ? "assistant-text" : "user-text";
-      let chatBox = document.getElementById("chatBox");
-
-      if (role === "assistant") {
-          // try to find the last assistant message and append to it
-          let last_message = chatBox.querySelector(`.${div_class}:last-of-type`);
-          if (last_message) {
-              last_message.textContent += text;
-              chatBox.scrollTop = chatBox.scrollHeight;
-              return;
-          }
-      }
-
-      // create a new message div if no previous assistant message exists
-      let message_div = document.createElement("div");
-      message_div.className = div_class;
-      message_div.textContent = text;
-      chatBox.appendChild(message_div);
-      chatBox.scrollTop = chatBox.scrollHeight;
-  }
-
-  // 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;
-  }
-
-  // send message to AI assistant, get response and place in chat box text area
-  async function send_message() {
-      // check connection to OpenAI
-      if (!(await check_connection())) {
-          return;
-      }
-
-      let userInput = document.getElementById("userInput").value;
-      if (!userInput.trim()) return;
-
-      // display user input and clear input field
-      add_text_to_chat(userInput, "user");
-      document.getElementById("userInput").value = "";
-
-      // fetch response from assistant
-      let response = await get_assistant_response(userInput);
-
-      // display assistant response
-      add_text_to_chat(response, "assistant");
-  }
-
-  //
-  // methods below here interact directly with the OpenAI API
-  //
-
-  // check connection to OpenAI API and return true on succes, false on failure
-  async function check_connection() {
-      // check openai API key
-      if (!get_openai_api_key()) {
-          return false;
-      }
-      // check openai connection
-      if (!openai) {
-          openai = new OpenAI({apiKey: get_openai_api_key(), dangerouslyAllowBrowser: true});
-          if (!openai) {
-              return false;
-          }
-      }
-
-      // return immediately if assistant id has already been found
-      if (openai_assistant_id) {
-          return true
-      }
-
-      let assistantId = await find_assistant(OPENAI_ASSISTANT_NAME);
-      if (assistantId) {
-          // store assistant id
-          openai_assistant_id = assistantId
-          document.getElementById("assistantId").value = assistantId;
-
-          // create a new thread
-          openai_thread_id = await create_thread();
-          if (!openai_thread_id) {
-              alert("Error: Unable to create a new OpenAI thread");
-              return false;
-          }
-          // print thread id on the page
-          document.getElementById("assistantThreadId").value = openai_thread_id;
-
-          // setup event handler
-          openai_event_handler = new EventHandler(openai)
-          if (!openai_event_handler) {
-              alert("Error: Unable to create event handler");
-              return false;
-          }
-          openai_event_handler.on("event", openai_event_handler.onEvent.bind(openai_event_handler))
-          return true;
-      } else {
-          alert("Error: Assistant not found. Please check your OpenAI API key and assistant name");
-          return false;
-      }
-  }
-
-  // get assistant response based on user input
-  async function find_assistant(assistant_name) {
-      // sanity check openai connection
-      if (!openai) {
-          return null;
-      }
-
-      try {
-          // get a list of all assistants
-          const assistants_list = await openai.beta.assistants.list({order: "desc", limit: 20});
-
-          // iterate through assistants and find the one with the matching name
-          let assistant = assistants_list.data.find(a => a.name === assistant_name);
-
-          // return assistant ID if found, otherwise return null
-          return assistant ? assistant.id : null;
-      } catch (error) {
-          // return null in case of an error
-          return null;
-      }
-  }
-
-  // create a new thread
-  // returns thread id on success, null on failure
-  async function create_thread() {
-    // sanity check the assistant id
-    if (!openai_assistant_id) {
-        return null;
-    }
-
-    try {
-        // create a thread
-        const new_thread = await openai.beta.threads.create();
-        return new_thread ? new_thread.id : null;
-    } catch (error) {
-        return null;
-    }
-  }
-
-  // get assistant response based on user input
-  async function get_assistant_response(input) {
-      // sanity check the assistant id
-      if (!openai_assistant_id) {
-          return "get_assistant_response: assistant not found";
-      }
-      // sanity check thread
-      if (!openai_thread_id) {
-          return "get_assistant_response: thread not found";
-      }
-
-      // add a message to the thread
-      const message = await openai.beta.threads.messages.create(openai_thread_id, { role: "user", content: input });
-
-      // run the assistant
-      const stream = await openai.beta.threads.runs.stream(openai_thread_id, { assistant_id: openai_assistant_id, stream: true })
-      stream.on('event', (event) => openai_event_handler.emit("event", event))
-  }
-
-  // handle function call from assistant
-  function handle_function_call(name, args) {
-      add_text_to_debug("Function call: " + name + " with args: " + JSON.stringify(args));
-      // call the function
-      switch (name) {
-          case "get_vehicle_type":
-              // get the vehicle type (e.g. Copter, Plane, Rover, Boat, etc)
-              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
-              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.
-              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
-              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
-              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
-              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
-              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
-              return get_location_plus_dist_at_bearing(args);
-          case "get_parameter_description":
-              // Get vehicle parameter descriptions including description, units, min and max
-              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
-              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);
-              return "Unknown function: " + name;
-          case "get_current_datetime":
-              // Get the current date and time, e.g. 'Saturday, June 24, 2023 6:14:14 PM
-              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
-              return get_mode_mapping(args);
-          case "get_all_parameters":
-              // Get all available parameter names and values
-              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);
-              return "Unknown function: " + name;
-          case "get_available_mavlink_messages":
-              return get_available_mavlink_messages();
-          default:
-              add_text_to_debug("Unknown function: " + name);
-              return "Unknown function: " + name;
-      }
-  }
-
-    // function calls below here
-    // returns "Copter", "Plane", "Rover", "Boat", etc or "Unknown"
-    function get_vehicle_type() {
-
-        // get the latest HEARTBEAT message and perform a sanity check
-        let heartbeat_msg = mavlink_store.get_latest_message(0);
-        //add_text_to_debug("get_vehicle_type: got latest msg" + JSON.stringify(heartbeat_msg));
-        if (!heartbeat_msg || !heartbeat_msg.hasOwnProperty("type")) {
-            return "unknown because no HEARTBEAT message has been received from the vehicle";
-        }
-        let vehicle_type = heartbeat_msg["type"];
-
-        // get the vehicle type from the heartbeat message's type field
-        switch (vehicle_type) {
-            case mavlink20.MAV_TYPE_FIXED_WING:
-            case mavlink20.MAV_TYPE_VTOL_DUOROTOR:
-            case mavlink20.MAV_TYPE_VTOL_QUADROTOR:
-            case mavlink20.MAV_TYPE_VTOL_TILTROTOR:
-                return "Plane"
-            case mavlink20.MAV_TYPE_GROUND_ROVER:
-                return "Rover";
-            case mavlink20.MAV_TYPE_SURFACE_BOAT:
-                return "Boat";
-            case mavlink20.MAV_TYPE_SUBMARINE:
-                return "Sub";
-            case mavlink20.MAV_TYPE_QUADROTOR:
-            case mavlink20.MAV_TYPE_COAXIAL:
-            case mavlink20.MAV_TYPE_HEXAROTOR:
-            case mavlink20.MAV_TYPE_OCTOROTOR:
-            case mavlink20.MAV_TYPE_TRICOPTER:
-            case mavlink20.MAV_TYPE_DODECAROTOR:
-                return "Copter";
-            case mavlink20.MAV_TYPE_HELICOPTER:
-                return "Heli";
-            case mavlink20.MAV_TYPE_ANTENNA_TRACKER:
-                return "Tracker";
-            case mavlink20.MAV_TYPE_AIRSHIP:
-                return "Blimp";
-            default:
-                add_text_to_debug("get_vehicle_type: default, unknown");
-                return "unknown";
-        }
-
-        // if we got this far  we don't know the vehicle type
-        add_text_to_debug("get_vehicle_type: no match for type:" + hearbeat_msg.type);
-        return "unknown";
-    }
-
-    // get names of all available mavlink messages
-    function get_available_mavlink_messages() {
-        // get the available message names
-        let msg_names = mavlink_store.get_available_message_names();
-        if (!msg_names) {
-            return "No available messages";
-        }
-        return msg_names.join(", ");
-    }
-
-  // get the current time and date as a string. E.g. 'Saturday, June 24, 2023 6:14:14 PM'
-  function getFormattedDate() {
-      const options = {
-          weekday: 'long', 
-          year: 'numeric', 
-          month: 'long', 
-          day: 'numeric', 
-          hour: 'numeric', 
-          minute: 'numeric', 
-          second: 'numeric', 
-          hour12: true 
-      };
-      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()
-            this.client = client;
-        }
-
-        async onEvent(event) {
-            try {
-                // print status on html page
-                document.getElementById("assistantRunStatus").value = event.event;
-
-                // handle each event
-                switch (event.event) {
-                // retrieve events that are denoted with 'requires_action'
-                // since these will have our tool_calls
-                case "thread.run.requires_action":
-                    await this.handleRequiresAction(
-                        event.data,
-                        event.data.id,
-                        event.data.thread_id,
-                    )
-                    break;
-                case "thread.message.delta":
-                case "thread.run.step.delta":
-                    let delta_text = event.data.delta.content[0].text.value
-                    add_text_to_chat(delta_text, "assistant")
-                    break;
-
-                // events below can be ignored
-                case "thread.created":
-                case "thread.message.completed":
-                case "thread.run.created":
-                case "thread.run.queued":
-                case "thread.run.in_progress":
-                case "thread.run.completed":
-                case "thread.run.incomplete":
-                case "thread.run.failed":
-                case "thread.run.step.created":
-                case "thread.run.cancelling":
-                case "thread.run.step.in_progress":
-                case "thread.run.cancelled":
-                case "thread.run.expired":
-                case "thread.run.step.created":
-                case "thread.run.step.in_progress":
-                case "thread.run.step.completed":
-                case "thread.run.step.failed":
-                case "thread.run.step.cancelled":
-                case "thread.run.step.expired":
-                case "thread.message.created":
-                case "thread.message.in_progress":
-                case "thread.message.completed":
-                case "thread.message.incomplete":
-                case "error":
-                case "done":
-                    break;
-
-                // catch unhandled events
-                default:
-                    add_text_to_debug("Unhandled event: " + event.event)
-                    console.log(event)
-                }
-
-            } catch (error) {
-                console.error("Error handling event:", error)
-            }
-        }
-
-        // 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 {
-                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) {
-            try {
-                // use the submitToolOutputsStream helper
-                const stream = this.client.beta.threads.runs.submitToolOutputsStream(
-                    threadId,
-                    runId,
-                    { tool_outputs: toolOutputs },
-                )
-                for await (const event of stream) {
-                    this.emit("event", event)
-                }
-            } catch (error) {
-                console.error("Error submitting tool outputs:", error)
-            }
-        }
-    }
-</script>
-</body>
-</html>
diff --git a/Chat/index.html b/Chat/index.html
index df69f46e..0c3b68e0 100644
--- a/Chat/index.html
+++ b/Chat/index.html
@@ -64,7 +64,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
     <div class="input-container">
         <button id="sendButton">Rec</button>
         <input type="text" id="userInput" class="input-field" placeholder="Type a message...">
-        <button class="send-button" onclick="send_message()">Send</button>
+        <button class="send-button" id="sendMessageButton" >Send</button>
     </div>
   </div>
 
@@ -96,7 +96,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
   <!-- MAVLink connection button -->
   <div class="mavlink-connection-container">
       <label for="MAVLinkConnection">MAVLink Connect:</label>
-      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:8765">            <!-- MAVLink connection -->
+      <input type="text" id="mavlink-connect-url" class="input-field" value="ws://127.0.0.1:56781" readonly>
       <button id="mavlink-connect-button">Connect</button>
   </div>
 
@@ -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>
@@ -116,8 +122,6 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
     // imports
     import { mavlink_store } from './MAVLink/mavlink_store.js';
 
-    let latest_heartbeat_message = null;
-
     // show/hide the OpenAI API key field
     function toggle_openai_api_key_visibility() {
         let openai_key_input = document.getElementById("openai_api_key");
@@ -127,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() {
@@ -173,7 +181,6 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
             // set up event handlers
             mavlink_ws.onopen = function() {
                 mavlink_set_connect_state(true);
-                add_text_to_debug("WebSocket CONNECTED successfully!");
             };
             mavlink_ws.onclose = function() {
                 mavlink_set_connect_state(false);
@@ -182,100 +189,21 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
                 mavlink_disconnect();
             };
 
-            // Replace your onmessage handler with this for better debugging:
-            // mavlink_ws.onmessage = (msg) => {
-
-            //     if (MAVLink == null) {
-            //         return;
-            //     }
-
-            //     // Debug data type
-            //     // add_text_to_debug("⚡ Received data type: " + typeof(msg.data));
-            //     // add_text_to_debug("msg is: "+msg.data);
-                
-            //     // Handle different data types
-            //     let dataArray;
-            //     if (typeof msg.data === 'string') {
-            //         // add_text_to_debug("String data received - converting to bytes");
-            //         // dataArray = new TextEncoder().encode(msg.data);
-
-            //         for (const char of new Uint8Array(msg.data)) {
-            //             add_text_to_debug("1");
-            //             const mavlink_msg = MAVLink.parseChar(char)
-            //             add_text_to_debug("2");
-            //             if ((mavlink_msg != null) && (mavlink_msg._id != -1)) {
-            //                 // got a message with a known ID
-            //                 add_text_to_debug("3");
-            //                 mavlink_msg_handler(mavlink_msg);
-            //                 add_text_to_debug("yayyy");
-            //             }
-            //         }
-
-            //     } else if (msg.data instanceof ArrayBuffer) {
-            //         dataArray = new Uint8Array(msg.data);
-            //     } else if (msg.data instanceof Blob) {
-            //         add_text_to_debug("Blob data received - reading as ArrayBuffer");
-            //         // Need to read the Blob asynchronously
-            //         const reader = new FileReader();
-            //         reader.onload = function() {
-            //             const arrayBuffer = reader.result;
-            //             const bytes = new Uint8Array(arrayBuffer);
-            //             processMavlinkBytes(bytes);
-            //         };
-            //         reader.readAsArrayBuffer(msg.data);
-            //         return;
-            //     } else {
-            //         add_text_to_debug("❌ Unknown data type received");
-            //         return;
-            //     }
-                
-            //     // processMavlinkBytes(dataArray);
-            // };
-
+            // parse incoming message and forward
             mavlink_ws.onmessage = (msg) => {
+                // sanity check parser has been created
                 if (MAVLink == null) {
                     return;
                 }
-
-                // Debug data type
-                // add_text_to_debug("Received data of type: " + typeof(msg.data));
-                
-                let dataArray;
-                if (typeof msg.data === 'string') {
-                    // Properly convert string to bytes
-                    // add_text_to_debug("Converting string data to bytes");
-                    const encoder = new TextEncoder();
-                    dataArray = encoder.encode(msg.data);
-                } else if (msg.data instanceof ArrayBuffer) {
-                    dataArray = new Uint8Array(msg.data);
-                } else if (msg.data instanceof Blob) {
-                    // Handle asynchronously
-                    const reader = new FileReader();
-                    reader.onload = function() {
-                        processMavlinkBytes(new Uint8Array(reader.result));
-                    };
-                    reader.readAsArrayBuffer(msg.data);
-                    return;
-                } else {
-                    add_text_to_debug("❌ Unknown data type received");
-                    return;
-                }
-                
-                // Process the bytes
-                processMavlinkBytes(dataArray);
-            };
-
-            function processMavlinkBytes(bytes) {
-                // add_text_to_debug("Processing " + bytes.length + " bytes");
-                for (const byte of bytes) {
-                    const mavlink_msg = MAVLink.parseChar(byte);
-                    if (mavlink_msg && mavlink_msg._id !== -1) {
-                        // add_text_to_debug("Parsed message ID: " + mavlink_msg._id);
+                // parse message
+                for (const char of new Uint8Array(msg.data)) {
+                    const mavlink_msg = MAVLink.parseChar(char)
+                    if ((mavlink_msg != null) && (mavlink_msg._id != -1)) {
+                        // got a message with a known ID
                         mavlink_msg_handler(mavlink_msg);
                     }
                 }
             }
-
         }
     }
 
@@ -295,13 +223,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
             return;
         }
 
-        // Store directly if this is a heartbeat message
-        if (msg._id === 0) { // HEARTBEAT
-            latest_heartbeat_message = msg;
-            add_text_to_debug("⭐ Stored heartbeat directly: type=" + msg.type);
-        }
-
-        // Still store in mavlink_store for other functions
+        // store the message in the message store
         mavlink_store.store_message(msg);
 
         switch (msg._id) {
@@ -369,6 +291,41 @@ <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");
@@ -376,6 +333,73 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
         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">
@@ -416,6 +440,8 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
           send_message();
       }
   })
+  // listener for send message button click
+  document.getElementById("sendMessageButton").addEventListener("click", send_message);
 
   // get openai API key (use this in API calls)
   function get_openai_api_key() {
@@ -474,14 +500,11 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
 
       // fetch response from assistant
       let response = await get_assistant_response(userInput);
-      
-      
+
       // display assistant response
       add_text_to_chat(response, "assistant");
   }
 
-  window.send_message = send_message;
-
   //
   // methods below here interact directly with the OpenAI API
   //
@@ -556,6 +579,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
       }
   }
 
+  // create a new thread
   // returns thread id on success, null on failure
   async function create_thread() {
     // sanity check the assistant id
@@ -588,11 +612,7 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
 
       // run the assistant
       const stream = await openai.beta.threads.runs.stream(openai_thread_id, { assistant_id: openai_assistant_id, stream: true })
-      stream.on('event', (event) => {
-        //   add_text_to_debug("Event received: " + event.event);
-          openai_event_handler.emit("event", event);
-      });
-    //   stream.on('event', (event) => openai_event_handler.emit("event", event))
+      stream.on('event', (event) => openai_event_handler.emit("event", event))
   }
 
   // handle function call from assistant
@@ -605,13 +625,13 @@ <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
-              get_vehicle_location_and_yaw();
+              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
@@ -620,22 +640,23 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
               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);
@@ -645,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);
@@ -663,7 +684,6 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
 
     // function calls below here
     // returns "Copter", "Plane", "Rover", "Boat", etc or "Unknown"
-
     function get_vehicle_type() {
 
         // get the latest HEARTBEAT message and perform a sanity check
@@ -735,55 +755,894 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
       return new Date().toLocaleString('en-US', options);
   }
 
-  // Add this function alongside your other function implementations
-  function get_vehicle_state() {
-        // Get the latest HEARTBEAT message
-        let heartbeat_msg = mavlink_store.get_latest_message(0);
-        if (!heartbeat_msg) {
-            return JSON.stringify({
-                armed: false,
-                mode: 0
-            });
-        }
 
+    //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_vehicle_location_and_yaw() {
-            // Get the latest GLOBAL_POSITION_INT message
-            let position_msg = mavlink_store.get_latest_message(33);
-            if (!position_msg) {
-                return JSON.stringify({
-                    error: "No position information available"
-                });
+    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);
             
-            // Extract coordinates (convert from degE7 to decimal degrees)
-            const lat = position_msg.lat / 1e7;
-            const lon = position_msg.lon / 1e7;
-            const alt_msl = position_msg.alt / 1000;  // mm to meters
-            const alt_relative = position_msg.relative_alt / 1000;  // mm to meters
+            // 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" });
+            }
             
-            return JSON.stringify({
-                latitude: lat,
-                longitude: lon,
-                altitude_msl: alt_msl,
-                altitude_relative: alt_relative,
-                heading: position_msg.hdg / 100  // centi-degrees to degrees
-            });
+            // 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;
         
-        // Get armed status
-        const armed = heartbeat_msg.base_mode & mavlink20.MAV_MODE_FLAG_SAFETY_ARMED ? true : false;
-        
-        // Get current mode
-        const mode_number = heartbeat_msg.custom_mode;
+        // 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({
-            armed: armed,
-            mode: mode_number
+            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()
@@ -852,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) {
@@ -889,4 +1798,4 @@ <h1><a href="" style="color: #000000; text-decoration:none;">Chat</a></h1>
     }
 </script>
 </body>
-</html>
\ No newline at end of file
+</html>