@cuekit-ai/react 1.3.4 → 1.4.0

package/dist/index.js

@@ -112,15 +112,24 @@ var init_intent_store = __esm({
 
 // src/core/navigation.ts
 function setNavigationHandler(handler) {
+  console.log("\u{1F9ED} setNavigationHandler called with:", !!handler);
   navigationHandler = handler;
 }
 function navigate(path2, params) {
   const safeParams = params || {};
   const absolutePath = path2.startsWith("/") ? path2 : `/${path2}`;
+  console.log("\u{1F9ED} navigate() called with:", {
+    path: path2,
+    absolutePath,
+    safeParams,
+    hasNavigationHandler: !!navigationHandler
+  });
   if (navigationHandler) {
     try {
+      console.log("\u{1F9ED} Using navigationHandler:", absolutePath, safeParams);
       navigationHandler(absolutePath, safeParams);
     } catch (error) {
+      console.error("\u{1F9ED} NavigationHandler error:", error);
     }
     return;
   }
@@ -135,13 +144,22 @@ function navigate(path2, params) {
     navigation.push(fullPath);
   } else {
     if (typeof window !== "undefined") {
-      window.location.href = fullPath;
+      if (window.location.hash && window.location.hash.startsWith("#")) {
+        window.location.hash = fullPath;
+      } else {
+        window.location.href = fullPath;
+      }
     }
   }
 }
 function getCurrentScreenName() {
   try {
     const path2 = getCurrentPath();
+    const pathParams = getCurrentPathParams();
+    if (path2 && Object.keys(pathParams).length > 0) {
+      const paramString = Object.entries(pathParams).map(([key, value]) => `${key}=${value}`).join(",");
+      return `${path2}?${paramString}`;
+    }
     return path2 || "UnknownScreen";
   } catch (e3) {
     return "UnknownScreen";
@@ -163,6 +181,45 @@ function getCurrentRouteParams() {
     return {};
   }
 }
+function getCurrentPathParams() {
+  try {
+    const currentPath = getCurrentPath();
+    const params = {};
+    const numericIdMatch = currentPath.match(/\/(\d+)(?:\/|$)/);
+    if (numericIdMatch) {
+      params.id = numericIdMatch[1];
+    }
+    const uuidMatch = currentPath.match(
+      /\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:\/|$)/i
+    );
+    if (uuidMatch) {
+      params.uuid = uuidMatch[1];
+    }
+    const slugMatch = currentPath.match(/\/([a-z0-9-]+)(?:\/|$)/i);
+    if (slugMatch && !numericIdMatch && !uuidMatch) {
+      params.slug = slugMatch[1];
+    }
+    return params;
+  } catch (e3) {
+    return {};
+  }
+}
+function resolveRoutePath(routePath, params) {
+  try {
+    let resolvedPath = routePath;
+    Object.entries(params).forEach(([key, value]) => {
+      const placeholder = `:${key}`;
+      if (resolvedPath.includes(placeholder)) {
+        resolvedPath = resolvedPath.replace(placeholder, value);
+      }
+    });
+    resolvedPath = resolvedPath.replace(/:\w+/g, "");
+    resolvedPath = resolvedPath.replace(/\/+/g, "/");
+    return resolvedPath;
+  } catch (e3) {
+    return routePath;
+  }
+}
 function onStateChange() {
   const routeName = getCurrentScreenName();
   const params = getCurrentRouteParams();
@@ -202,16 +259,26 @@ var init_navigation = __esm({
     navigationHandler = null;
     getCurrentPath = () => {
       if (typeof window === "undefined") return "";
+      if (window.location.hash && window.location.hash.startsWith("#")) {
+        const hashPath = window.location.hash.substring(1);
+        return hashPath.split("?")[0];
+      }
       return window.location.pathname;
     };
     getSearchParams = () => {
       if (typeof window === "undefined") return new URLSearchParams();
+      if (window.location.hash && window.location.hash.includes("?")) {
+        const queryString = window.location.hash.split("?")[1];
+        return new URLSearchParams(queryString);
+      }
       return new URLSearchParams(window.location.search);
     };
     safeNavigate = (name2, params = {}) => {
+      console.log("\u{1F9ED} safeNavigate called with:", { name: name2, params });
       if (name2) {
         navigate(name2, params);
       } else {
+        console.log("\u{1F9ED} safeNavigate: no name provided, skipping navigation");
       }
     };
     handleNavigationAndClick = (routeName, elementHash) => {
@@ -22916,6 +22983,13 @@ function getInteractiveElements() {
 }
 function getImmediateText(element3) {
   let text7 = "";
+  const textAttributes = ["label", "text", "placeholder", "title", "alt", "aria-label"];
+  for (const attr of textAttributes) {
+    const value = element3.getAttribute(attr);
+    if (value) {
+      text7 += value + " ";
+    }
+  }
   if (element3.childNodes) {
     for (const node2 of Array.from(element3.childNodes)) {
       if (node2.nodeType === 3) {
@@ -22925,12 +22999,30 @@ function getImmediateText(element3) {
   }
   return text7.trim();
 }
-function captureFullDOMStructure() {
-  console.log("\u{1F333} Capturing full DOM structure for Cuekit...");
-  const interactiveElements = [];
+function executeAction(action) {
+  console.log("\u{1F3AF} Executing element action:", action);
+  const { action_type, target_element, target } = action;
+  switch (action_type) {
+    case "click":
+      return clickElement(target_element);
+    case "navigate":
+      return navigateToElement(target_element || target);
+    case "input":
+    case "focus":
+      return focusElement(target_element);
+    case "toggle":
+      return toggleElement(target_element);
+    default:
+      console.warn(`\u26A0\uFE0F Unknown action type: ${action_type}`);
+      return false;
+  }
+}
+function captureAllInteractiveElements() {
+  console.log("\u{1F333} Capturing ALL interactive elements for Cuekit...");
+  const interactiveElements = {};
   const descriptionsMap = /* @__PURE__ */ new Map();
-  document.querySelectorAll("[data-for]").forEach((el) => {
-    const targetId = el.getAttribute("data-for");
+  document.querySelectorAll("[data-ansyr-for]").forEach((el) => {
+    const targetId = el.getAttribute("data-ansyr-for");
     if (!targetId) return;
     const tags = [];
     const description = el.getAttribute("data-ansyr-description");
@@ -22945,110 +23037,115 @@ function captureFullDOMStructure() {
       descriptionsMap.set(targetId, [...existingTags, ...tags]);
     }
   });
-  const allElements = getInteractiveElements();
-  allElements.forEach((element3) => {
+  const allInteractiveElements = getInteractiveElements();
+  console.log("\u{1F333} Found", allInteractiveElements.length, "interactive elements");
+  allInteractiveElements.forEach((element3) => {
+    if (!(element3 instanceof HTMLElement)) return;
     const style = getComputedStyle(element3);
-    if (element3.closest("[data-cuekit-ignore]") || !isElementClickable(element3) || element3.tagName.toLowerCase() === "script" || style.display === "none" || style.visibility === "hidden") {
+    if (element3.closest("[data-cuekit-ignore]") || element3.tagName.toLowerCase() === "script" || style.display === "none" || style.visibility === "hidden") {
       return;
     }
+    let elementId = null;
     const staticId = element3.getAttribute("data-ansyr-static");
     const dynamicId = element3.getAttribute("data-ansyr-dynamic");
-    const id = staticId || dynamicId;
+    if (staticId) {
+      elementId = staticId;
+      console.log("\u{1F333} Using pre-assigned static ID:", elementId);
+    } else if (dynamicId) {
+      elementId = dynamicId;
+      console.log("\u{1F333} Using pre-assigned dynamic ID:", elementId);
+    } else {
+      elementId = generateStableDOMId(element3);
+      console.log("\u{1F333} Calculated stable DOM ID:", elementId);
+    }
+    if (!elementId) {
+      console.log("\u{1F333} No ID could be determined for element:", element3);
+      return;
+    }
     const tags = [];
     const directDescription = element3.getAttribute("data-ansyr-description");
     if (directDescription) {
       tags.push(directDescription);
     }
-    if (id && descriptionsMap.has(id)) {
-      tags.push(...descriptionsMap.get(id) || []);
-    }
-    const dto = {
-      testID: id || generateStableDOMId(element3),
-      type: element3.tagName.toLowerCase(),
-      textContent: getImmediateText(element3) || element3.textContent?.trim() || "",
-      tags
-    };
-    interactiveElements.push(dto);
+    if (descriptionsMap.has(elementId)) {
+      tags.push(...descriptionsMap.get(elementId) || []);
+    }
+    const textContent = getImmediateText(element3) || element3.textContent?.trim() || "";
+    interactiveElements[elementId] = [textContent, ...tags];
+    console.log("\u{1F333} Captured element:", {
+      id: elementId,
+      tagName: element3.tagName,
+      textContent: textContent.substring(0, 50),
+      hasStaticId: !!staticId,
+      hasDynamicId: !!dynamicId,
+      isCalculated: !staticId && !dynamicId
+    });
   });
   const result = {
     components: interactiveElements
   };
-  console.log("\u{1F333} Full DOM structure captured:", result);
+  console.log("\u{1F333} All interactive elements captured:", result);
   return result;
 }
-function isElementClickable(element3) {
-  const interactiveSelectors = [
-    "button",
-    "a",
-    "input",
-    "select",
-    "textarea",
-    '[role="button"]',
-    '[role="link"]',
-    '[role="tab"]',
-    "[data-onclick-id]",
-    "[data-on-press-id]",
-    "[onclick]",
-    "[onmousedown]",
-    "[onmouseup]",
-    "[ontouchstart]",
-    "[ontouchend]",
-    "[onkeydown]",
-    "[onkeyup]",
-    "[onkeypress]"
-  ];
-  for (const selector of interactiveSelectors) {
-    if (element3.matches(selector)) {
-      return true;
-    }
-  }
-  const hasClickEvents = element3.onclick !== null || element3.getAttribute("onclick") !== null;
-  const hasInteractiveEvents = element3.ontouchstart !== null || element3.getAttribute("ontouchstart") !== null || element3.ontouchend !== null || element3.getAttribute("ontouchend") !== null || element3.onkeydown !== null || element3.getAttribute("onkeydown") !== null || element3.onkeyup !== null || element3.getAttribute("onkeyup") !== null || element3.onkeypress !== null || element3.getAttribute("onkeypress") !== null;
-  const hasPointerCursor = element3.style.cursor === "pointer" || getComputedStyle(element3).cursor === "pointer";
-  const hasTabIndex = element3.hasAttribute("tabindex") && parseInt(element3.getAttribute("tabindex") || "0") >= 0;
-  const hasInteractiveDataAttrs = element3.hasAttribute("data-clickable") || element3.hasAttribute("data-interactive") || element3.hasAttribute("data-action") || element3.hasAttribute("data-handler");
-  const hasInteractiveAria = element3.hasAttribute("aria-pressed") || element3.hasAttribute("aria-expanded") || element3.hasAttribute("aria-selected") || element3.hasAttribute("aria-checked");
-  return hasClickEvents || hasInteractiveEvents || hasPointerCursor || hasTabIndex || hasInteractiveDataAttrs || hasInteractiveAria;
+function clearElementCache() {
+  elementCache.clear();
+  cacheTimestamp = 0;
 }
-function executeAction(action) {
-  console.log("\u{1F3AF} Executing element action:", action);
-  const { action_type, target_element, target } = action;
-  switch (action_type) {
-    case "click":
-      return clickElement(target_element);
-    case "navigate":
-      return navigateToElement(target_element || target);
-    case "input":
-    case "focus":
-      return focusElement(target_element);
-    case "toggle":
-      return toggleElement(target_element);
-    default:
-      console.warn(`\u26A0\uFE0F Unknown action type: ${action_type}`);
-      return false;
+function validateDynamicElements() {
+  if (false) {
+    const elements = document.querySelectorAll("[data-ansyr-dynamic]");
+    const ids = /* @__PURE__ */ new Set();
+    const duplicates = [];
+    elements.forEach((element3) => {
+      const id = element3.getAttribute("data-ansyr-dynamic");
+      if (id) {
+        if (ids.has(id)) {
+          duplicates.push(id);
+        }
+        ids.add(id);
+      }
+    });
+    if (duplicates.length > 0) {
+      console.warn("\u{1F6A8} CueKit: Duplicate dynamic IDs found:", duplicates);
+      console.warn(
+        "This can cause incorrect element targeting. Ensure each dynamic element has a unique identifier."
+      );
+    }
   }
 }
-function getFullDOMStructure() {
-  return captureFullDOMStructure();
-}
 function clickElement(elementId) {
+  console.log("\u{1F5B1}\uFE0F clickElement called with:", elementId);
   if (!elementId) {
+    console.log("\u{1F5B1}\uFE0F clickElement: no elementId provided");
     return false;
   }
   const domElement = findDOMElementById(elementId);
+  console.log("\u{1F5B1}\uFE0F clickElement: found DOM element:", domElement);
   if (domElement) {
+    console.log("\u{1F5B1}\uFE0F clickElement: attempting to click element:", {
+      tagName: domElement.tagName,
+      id: domElement.id,
+      className: domElement.className,
+      textContent: domElement.textContent?.substring(0, 50)
+    });
     domElement.click();
+    console.log("\u{1F5B1}\uFE0F clickElement: click() called successfully");
     return true;
   }
+  console.log("\u{1F5B1}\uFE0F clickElement: element not found");
   return false;
 }
 function navigateToElement(target) {
+  console.log("\u{1F9ED} navigateToElement called with:", target);
   if (!target) {
+    console.log("\u{1F9ED} navigateToElement: no target provided");
     return false;
   }
   if (target.includes("/") || target.startsWith("http")) {
+    console.log("\u{1F9ED} navigateToElement: using safeNavigate for path:", target);
     safeNavigate(target, {});
   } else {
+    console.log("\u{1F9ED} navigateToElement: using handleNavigationAndClick for element:", target);
     handleNavigationAndClick(target, target);
   }
   return true;
@@ -23087,29 +23184,93 @@ function toggleElement(elementId) {
   }
 }
 function findDOMElementById(elementId) {
+  console.log("\u{1F50D} findDOMElementById called with:", elementId);
   if (!elementId) {
+    console.log("\u{1F50D} findDOMElementById: no elementId provided");
     return null;
   }
-  const interactiveElements = getInteractiveElements();
-  for (const element3 of interactiveElements) {
-    if (element3 instanceof HTMLElement) {
+  const now = Date.now();
+  if (now - cacheTimestamp < CACHE_TTL && elementCache.has(elementId)) {
+    const cachedElement = elementCache.get(elementId);
+    console.log("\u{1F50D} findDOMElementById: found in cache:", cachedElement);
+    if (document.contains(cachedElement)) {
+      console.log("\u{1F50D} findDOMElementById: returning cached element");
+      return cachedElement;
+    } else {
+      console.log("\u{1F50D} findDOMElementById: cached element no longer in DOM, removing from cache");
+      elementCache.delete(elementId);
+    }
+  }
+  let foundElement = null;
+  console.log(
+    "\u{1F50D} findDOMElementById: checking for static element with selector:",
+    `[data-ansyr-static="${elementId}"]`
+  );
+  const staticElement = document.querySelector(`[data-ansyr-static="${elementId}"]`);
+  if (staticElement instanceof HTMLElement) {
+    console.log("\u{1F50D} findDOMElementById: found static element:", staticElement);
+    foundElement = staticElement;
+  } else {
+    console.log(
+      "\u{1F50D} findDOMElementById: checking for dynamic element with selector:",
+      `[data-ansyr-dynamic="${elementId}"]`
+    );
+    const dynamicElement = document.querySelector(`[data-ansyr-dynamic="${elementId}"]`);
+    if (dynamicElement instanceof HTMLElement) {
+      console.log("\u{1F50D} findDOMElementById: found dynamic element:", dynamicElement);
+      foundElement = dynamicElement;
+    }
+  }
+  if (!foundElement) {
+    console.log(
+      "\u{1F50D} findDOMElementById: no pre-assigned element found, scanning all interactive elements"
+    );
+    const interactiveElements = getInteractiveElements();
+    console.log("\u{1F50D} findDOMElementById: found", interactiveElements.length, "interactive elements");
+    for (const element3 of interactiveElements) {
+      if (!(element3 instanceof HTMLElement)) continue;
       const staticId = element3.getAttribute("data-ansyr-static");
       const dynamicId = element3.getAttribute("data-ansyr-dynamic");
-      const currentElementId = staticId || dynamicId || generateStableDOMId(element3);
+      let currentElementId = null;
+      if (staticId) {
+        currentElementId = staticId;
+      } else if (dynamicId) {
+        currentElementId = dynamicId;
+      } else {
+        currentElementId = generateStableDOMId(element3);
+      }
       if (currentElementId === elementId) {
-        return element3;
+        console.log("\u{1F50D} findDOMElementById: found element by ID match:", {
+          element: element3,
+          id: currentElementId,
+          hasStaticId: !!staticId,
+          hasDynamicId: !!dynamicId,
+          isCalculated: !staticId && !dynamicId
+        });
+        foundElement = element3;
+        break;
       }
     }
+    if (!foundElement) {
+      console.log("\u{1F50D} findDOMElementById: element not found in interactive elements scan");
+    }
   }
-  return null;
+  if (foundElement) {
+    elementCache.set(elementId, foundElement);
+    cacheTimestamp = now;
+  }
+  return foundElement;
 }
-var INTERACTIVE_ELEMENT_SELECTOR;
+var INTERACTIVE_ELEMENT_SELECTOR, elementCache, cacheTimestamp, CACHE_TTL;
 var init_element_service = __esm({
   "src/utils/element-service.ts"() {
     "use strict";
     init_navigation();
     init_jsx_encoder();
-    INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, textarea, select, [role="button"], [onclick], [data-ansyr-static], [data-ansyr-dynamic]';
+    INTERACTIVE_ELEMENT_SELECTOR = 'a, button, select, [role="button"], [role="link"], [role="tab"], [onclick], [onmousedown], [onmouseup], [ontouchstart], [ontouchend], [onkeydown], [onkeyup], [onkeypress], [onchange], [onsubmit], [onfocus], [onblur], [data-ansyr-static], [data-ansyr-dynamic]';
+    elementCache = /* @__PURE__ */ new Map();
+    cacheTimestamp = 0;
+    CACHE_TTL = 5e3;
   }
 });
 
@@ -23119,6 +23280,7 @@ __export(webrtc_service_exports, {
   authenticate: () => authenticate,
   connectToRoom: () => connectToRoom,
   disconnectFromRoom: () => disconnectFromRoom,
+  getCurrentCallbacks: () => getCurrentCallbacks,
   getParticipants: () => getParticipants,
   getRoom: () => getRoom,
   getRoomName: () => getRoomName,
@@ -23139,8 +23301,16 @@ function setAudioContainer(newAudioContainerRef) {
   audioContainerRef = newAudioContainerRef;
 }
 function setWebRTCCallbacks(newCallbacks) {
+  console.log("\u{1F4E1} setWebRTCCallbacks called with:", {
+    hasOnNavigationCommand: !!newCallbacks.onNavigationCommand,
+    hasOnConnectionStateChange: !!newCallbacks.onConnectionStateChange,
+    hasOnParticipantUpdate: !!newCallbacks.onParticipantUpdate
+  });
   callbacks = newCallbacks;
 }
+function getCurrentCallbacks() {
+  return callbacks;
+}
 async function authenticate(userIdentity, apiKey, appId) {
   try {
     const authPayload = {
@@ -23231,12 +23401,34 @@ function setupEventListeners() {
     track.detach().forEach((element3) => element3.remove());
   }).on(RoomEvent.DataReceived, (payload, participant) => {
     const decodedPayload = new TextDecoder().decode(payload);
-    try {
-      const message = JSON.parse(decodedPayload);
-      callbacks.onNavigationCommand?.(message);
-    } catch (error) {
-      const message = decodedPayload;
-      callbacks.onNavigationCommand?.({ type: "raw_text", data: message });
+    console.log("\u{1F4E1} WebRTC DataReceived:", { decodedPayload, participant: participant?.identity });
+    if (decodedPayload.includes("|")) {
+      const parts = decodedPayload.split("|");
+      const textPart = parts[0];
+      const jsonPart = parts[1];
+      console.log("\u{1F4E1} WebRTC Pipe-separated message:", { textPart, jsonPart });
+      if (textPart) {
+        callbacks.onNavigationCommand?.({ type: "speech_text", data: textPart });
+      }
+      if (jsonPart) {
+        try {
+          const message = JSON.parse(jsonPart);
+          console.log("\u{1F4E1} WebRTC Parsed JSON message:", message);
+          callbacks.onNavigationCommand?.(message);
+        } catch (error) {
+          console.log("\u{1F4E1} WebRTC JSON parse error for JSON part:", error, "JSON part:", jsonPart);
+        }
+      }
+    } else {
+      try {
+        const message = JSON.parse(decodedPayload);
+        console.log("\u{1F4E1} WebRTC Parsed message:", message);
+        callbacks.onNavigationCommand?.(message);
+      } catch (error) {
+        console.log("\u{1F4E1} WebRTC JSON parse error:", error, "Raw payload:", decodedPayload);
+        const message = decodedPayload;
+        callbacks.onNavigationCommand?.({ type: "raw_text", data: message });
+      }
     }
   }).on(RoomEvent.Disconnected, () => {
     setWebRTCConnectionState({ isConnected: false, isConnecting: false });
@@ -23290,17 +23482,19 @@ async function sendUserCommand(command) {
   await sendData(command);
 }
 async function sendRuntimeData() {
+  console.log("\u{1F9E0} checking room:", room);
   if (!room) {
     return;
   }
+  console.log("\u{1F9E0} Sending runtime data", room);
   try {
-    const domStructure = captureFullDOMStructure();
+    const allInteractiveElements = captureAllInteractiveElements();
     const screenName = getCurrentScreenName();
     const response = {
       type: "runtime_data_response",
       data: {
-        components: domStructure.components,
-        current_screen: screenName
+        components: allInteractiveElements.components,
+        currentRoute: screenName
       }
     };
     await sendData(JSON.stringify(response));
@@ -24507,17 +24701,20 @@ __export(index_exports, {
   InitCuekit: () => InitCuekit,
   MicButton: () => MicButton,
   VoiceIntensityVisualizer: () => VoiceIntensityVisualizer,
-  captureFullDOMStructure: () => captureFullDOMStructure,
+  captureAllInteractiveElements: () => captureAllInteractiveElements,
+  clearElementCache: () => clearElementCache,
   configureWebRTCServer: () => configureWebRTCServer,
   executeAction: () => executeAction,
   generateDynamicId: () => generateDynamicId,
-  getFullDOMStructure: () => getFullDOMStructure,
+  getCurrentPathParams: () => getCurrentPathParams,
   getWebRTCServerConfig: () => getWebRTCServerConfig,
   initWebRTC: () => initWebRTC,
   initWebRTCWithDeployedBackend: () => initWebRTCWithDeployedBackend,
+  resolveRoutePath: () => resolveRoutePath,
   useCuekit: () => useCuekit,
   useQubeContext: () => useQubeContext,
-  useWebRTC: () => useWebRTC
+  useWebRTC: () => useWebRTC,
+  validateDynamicElements: () => validateDynamicElements
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -24651,25 +24848,12 @@ var CuekitProvider = ({
     Promise.resolve().then(() => (init_webrtc_service(), webrtc_service_exports)).then(({ setWebRTCCallbacks: setWebRTCCallbacks2 }) => {
       setWebRTCCallbacks2({
         onNavigationCommand: (command) => {
-          switch (command.type) {
-            case "static_data_ready":
-              break;
-            case "ai_intent":
-              if (command.actionType === "navigate" && command.current_page) {
-                if (navigationHandler2) {
-                  navigationHandler2(command.current_page, {
-                    intent: command.intent,
-                    text: command.text,
-                    confidence: command.confidence
-                  });
-                }
-              }
-              break;
-            case "user_speech_text":
-              break;
-            case "ai_speech_text":
-              break;
-            default:
+          if (command.data.actionType === "navigate" && command.data.routeName) {
+            if (navigationHandler2) {
+              navigationHandler2(command.data.routeName);
+            }
+          } else if (command.data.actionType === "click" && command.data.elementId) {
+            console.log("AI intent: Click element", command.data.elementId);
           }
         },
         onConnectionStateChange: (state) => {
@@ -24897,6 +25081,14 @@ var useCuekit = (options) => {
   const handleNavigationCommand = (event) => {
     console.log(`\u2B07\uFE0F Received event from backend: ${event.type}`, event);
     switch (event.type) {
+      case "speech_text": {
+        console.log("\u{1F5E3}\uFE0F AI Speech text:", event.data);
+        break;
+      }
+      case "raw_text": {
+        console.log("\u{1F4DD} Raw text message:", event.data);
+        break;
+      }
       case "user_speech_chunk":
       case "ai_speech_chunk": {
         const role = event.type === "user_speech_chunk" ? "user" : "ai";
@@ -24932,16 +25124,21 @@ var useCuekit = (options) => {
       }
       case "ai_intent": {
         const intent = event.data;
-        if (intent.actionType === "click" && intent.actionMetadata.elementId) {
+        console.log("\u{1F3AF} AI Intent received:", intent);
+        if (intent.actionType === "click" && intent.elementId) {
+          console.log("\u{1F3AF} Executing click action:", intent.elementId);
           executeAction({
             action_type: "click",
-            target_element: intent.actionMetadata.elementId
+            target_element: intent.elementId
           });
-        } else if (intent.actionType === "navigate" && intent.actionMetadata.routeName) {
+        } else if (intent.actionType === "navigate" && intent.routeName) {
+          console.log("\u{1F3AF} Executing navigate action:", intent.routeName);
           executeAction({
             action_type: "navigate",
-            target_element: intent.actionMetadata.routeName
+            target_element: intent.routeName
           });
+        } else {
+          console.log("\u{1F3AF} AI Intent not handled:", intent);
         }
         break;
       }
@@ -40556,9 +40753,7 @@ var MicButton = ({
     setStatus,
     participants
   } = useCuekit({
-    onNavigationCommand: (command) => {
-      console.log("\u{1F3A4} MicButton: Navigation command received:", command);
-    },
+    // Don't override navigation command - let the provider handle it
     onConnectionStateChange: (state) => {
       console.log("\u{1F3A4} MicButton: Connection state changed:", state);
     },
@@ -40947,4 +41142,4 @@ function generateDynamicId(routePath, elementIdentifier) {
 }
 
 // src/index.ts
-init_element_service();
+init_navigation();