@modelnex/sdk 0.5.14 → 0.5.16

package/dist/index.js

@@ -2324,7 +2324,7 @@ function useBuiltinActions(registerAction, unregisterAction, tagStore, serverUrl
 }
 
 // src/constants.ts
-var DEFAULT_MODELNEX_SERVER_URL = "https://modelnex-server-production.up.railway.app";
+var DEFAULT_MODELNEX_SERVER_URL = "https://api.modelnex.com";
 
 // src/hooks/useRunCommand.ts
 var import_react9 = require("react");
@@ -2626,6 +2626,7 @@ function isTourEligible(tour, userProfile) {
 
 // src/hooks/useTourPlayback.ts
 var import_react12 = require("react");
+var import_socket2 = require("socket.io-client");
 
 // src/utils/retryLookup.ts
 var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -3154,6 +3155,12 @@ function useTourPlayback({
   const [serverState, setServerState] = (0, import_react12.useState)(null);
   const ctx = (0, import_react12.useContext)(ModelNexContext);
   const devMode = ctx?.devMode;
+  const devModeRef = (0, import_react12.useRef)(devMode);
+  devModeRef.current = devMode;
+  const userProfileRef = (0, import_react12.useRef)(userProfile);
+  userProfileRef.current = userProfile;
+  const experienceTypeRef = (0, import_react12.useRef)(experienceType);
+  experienceTypeRef.current = experienceType;
   const tourRef = (0, import_react12.useRef)(null);
   const stepIndexRef = (0, import_react12.useRef)(0);
   const skipRequestedRef = (0, import_react12.useRef)(false);
@@ -3193,408 +3200,391 @@ function useTourPlayback({
   (0, import_react12.useEffect)(() => {
     if (disabled) return;
     if (typeof window === "undefined") return;
-    import("socket.io-client").then((ioModule) => {
-      const io2 = ioModule.default || ioModule;
-      const socket = io2(serverUrl, {
-        path: "/socket.io",
-        // standard
-        transports: resolveSocketIoTransports(serverUrl, "polling-first")
-      });
-      socketRef.current = socket;
-      socket.on("connect", () => {
-        console.log("[TourClient] Connected to tour agent server:", socket.id);
-        if (websiteId && userProfile) {
-          socket.emit("tour:init", { websiteId, userId: userProfile.userId, userType: userProfile.type });
-        }
-      });
-      socket.on("tour:server_state", (payload) => {
-        if (typeof payload?.runId === "number") {
-          runIdRef.current = payload.runId;
-        }
-        if (typeof payload?.turnId === "string" || payload?.turnId === null) {
-          turnIdRef.current = payload.turnId ?? null;
+    let createdSocket = null;
+    const socket = (0, import_socket2.io)(serverUrl, {
+      path: "/socket.io",
+      transports: resolveSocketIoTransports(serverUrl, "polling-first"),
+      autoConnect: true,
+      reconnection: true,
+      reconnectionAttempts: 10,
+      reconnectionDelay: 1e3
+    });
+    createdSocket = socket;
+    socketRef.current = socket;
+    socket.on("connect", () => {
+      console.log("[TourClient] Connected to tour agent server:", socket.id);
+      const profile = userProfileRef.current;
+      if (websiteId && profile?.userId && socket.connected) {
+        socket.emit("tour:init", { websiteId, userId: profile.userId, userType: profile.type });
+      }
+    });
+    socket.on("tour:server_state", (payload) => {
+      if (typeof payload?.runId === "number") {
+        runIdRef.current = payload.runId;
+      }
+      if (typeof payload?.turnId === "string" || payload?.turnId === null) {
+        turnIdRef.current = payload.turnId ?? null;
+      }
+      setServerState(payload);
+    });
+    socket.on("tour:command_cancel", (payload) => {
+      console.log("[TourClient] Received command_cancel:", payload);
+      if (payload.commandBatchId && activeCommandBatchIdRef.current === payload.commandBatchId) {
+        activeCommandBatchIdRef.current = null;
+        activeExecutionTokenRef.current++;
+        commandInFlightRef.current = false;
+        setPlaybackState("idle");
+        if (typeof window !== "undefined" && window.speechSynthesis) {
+          window.speechSynthesis.cancel();
         }
-        setServerState(payload);
-      });
-      socket.on("tour:command_cancel", (payload) => {
-        console.log("[TourClient] Received command_cancel:", payload);
-        if (payload.commandBatchId && activeCommandBatchIdRef.current === payload.commandBatchId) {
+      }
+    });
+    socket.on("tour:command", async (payload) => {
+      const emitIfOpen = (ev, data) => {
+        if (socketRef.current !== socket) return;
+        if (!socket.connected) return;
+        socket.emit(ev, data);
+      };
+      console.log("[TourClient] Received command batch:", payload.stepIndex, payload.commands);
+      runCleanup(pendingManualWaitCleanupRef.current);
+      pendingManualWaitCleanupRef.current = null;
+      if (voiceInputResolveRef.current) {
+        const resolvePendingVoiceInput = voiceInputResolveRef.current;
+        voiceInputResolveRef.current = null;
+        resolvePendingVoiceInput("");
+      }
+      setPlaybackState("executing");
+      commandInFlightRef.current = true;
+      const commandBatchId = payload.commandBatchId ?? null;
+      turnIdRef.current = payload.turnId ?? turnIdRef.current;
+      const clearCommandBatchId = () => {
+        if (activeCommandBatchIdRef.current === commandBatchId) {
           activeCommandBatchIdRef.current = null;
-          activeExecutionTokenRef.current++;
-          commandInFlightRef.current = false;
-          setPlaybackState("idle");
-          if (typeof window !== "undefined" && window.speechSynthesis) {
-            window.speechSynthesis.cancel();
-          }
         }
-      });
-      socket.on("tour:command", async (payload) => {
-        console.log("[TourClient] Received command batch:", payload.stepIndex, payload.commands);
-        runCleanup(pendingManualWaitCleanupRef.current);
-        pendingManualWaitCleanupRef.current = null;
-        if (voiceInputResolveRef.current) {
-          const resolvePendingVoiceInput = voiceInputResolveRef.current;
-          voiceInputResolveRef.current = null;
-          resolvePendingVoiceInput("");
-        }
-        setPlaybackState("executing");
-        commandInFlightRef.current = true;
-        const commandBatchId = payload.commandBatchId ?? null;
-        turnIdRef.current = payload.turnId ?? turnIdRef.current;
-        const clearCommandBatchId = () => {
-          if (activeCommandBatchIdRef.current === commandBatchId) {
-            activeCommandBatchIdRef.current = null;
+      };
+      activeCommandBatchIdRef.current = commandBatchId;
+      const executionToken = ++activeExecutionTokenRef.current;
+      const activeTourId = tourRef.current?.id;
+      const activePreviewRunId = previewRunIdRef.current;
+      if (reviewModeRef.current && activeTourId && activePreviewRunId && typeof payload.stepIndex === "number") {
+        void logPreviewEvent(serverUrl, toursApiBaseRef.current, activeTourId, activePreviewRunId, websiteId, {
+          stepOrder: payload.stepIndex,
+          eventType: "command_batch_received",
+          payload: {
+            commandBatchId,
+            commandTypes: Array.isArray(payload.commands) ? payload.commands.map((command) => command?.type || "unknown") : []
+          },
+          currentStepOrder: payload.stepIndex
+        });
+      }
+      if (typeof payload.stepIndex === "number") {
+        const prevStep = stepIndexRef.current;
+        stepIndexRef.current = payload.stepIndex;
+        setCurrentStepIndex(payload.stepIndex);
+        if (payload.stepIndex !== prevStep) {
+          const tour = tourRef.current;
+          const total = tour?.steps?.length ?? 0;
+          if (tour && total > 0) {
+            onStepChangeRef.current?.(payload.stepIndex, total, tour);
           }
-        };
-        activeCommandBatchIdRef.current = commandBatchId;
-        const executionToken = ++activeExecutionTokenRef.current;
-        const activeTourId = tourRef.current?.id;
-        const activePreviewRunId = previewRunIdRef.current;
-        if (reviewModeRef.current && activeTourId && activePreviewRunId && typeof payload.stepIndex === "number") {
+        }
+        if (reviewModeRef.current && activeTourId && activePreviewRunId) {
           void logPreviewEvent(serverUrl, toursApiBaseRef.current, activeTourId, activePreviewRunId, websiteId, {
             stepOrder: payload.stepIndex,
-            eventType: "command_batch_received",
+            eventType: "step_started",
             payload: {
-              commandBatchId,
-              commandTypes: Array.isArray(payload.commands) ? payload.commands.map((command) => command?.type || "unknown") : []
+              previousStepOrder: prevStep,
+              stepType: tourRef.current?.steps?.[payload.stepIndex]?.type ?? null
             },
             currentStepOrder: payload.stepIndex
           });
         }
-        if (typeof payload.stepIndex === "number") {
-          const prevStep = stepIndexRef.current;
-          stepIndexRef.current = payload.stepIndex;
-          setCurrentStepIndex(payload.stepIndex);
-          if (payload.stepIndex !== prevStep) {
-            const tour = tourRef.current;
-            const total = tour?.steps?.length ?? 0;
-            if (tour && total > 0) {
-              onStepChangeRef.current?.(payload.stepIndex, total, tour);
-            }
-          }
-          if (reviewModeRef.current && activeTourId && activePreviewRunId) {
-            void logPreviewEvent(serverUrl, toursApiBaseRef.current, activeTourId, activePreviewRunId, websiteId, {
-              stepOrder: payload.stepIndex,
-              eventType: "step_started",
-              payload: {
-                previousStepOrder: prevStep,
-                stepType: tourRef.current?.steps?.[payload.stepIndex]?.type ?? null
-              },
-              currentStepOrder: payload.stepIndex
-            });
-          }
-        }
-        if (!payload.commands || !Array.isArray(payload.commands)) {
-          console.warn("[TourClient] Payload commands is not an array:", payload);
-          commandInFlightRef.current = false;
-          socket.emit("tour:action_result", {
-            success: false,
-            reason: "invalid_commands",
-            commandBatchId,
-            runId: runIdRef.current,
-            turnId: turnIdRef.current
-          });
-          clearCommandBatchId();
-          return;
+      }
+      if (!payload.commands || !Array.isArray(payload.commands)) {
+        console.warn("[TourClient] Payload commands is not an array:", payload);
+        commandInFlightRef.current = false;
+        emitIfOpen("tour:action_result", {
+          success: false,
+          reason: "invalid_commands",
+          commandBatchId,
+          runId: runIdRef.current,
+          turnId: turnIdRef.current
+        });
+        clearCommandBatchId();
+        return;
+      }
+      let shouldWait = false;
+      const results = [];
+      let batchPreferredWaitTarget = null;
+      const assertNotInterrupted = () => {
+        if (executionToken !== activeExecutionTokenRef.current || skipRequestedRef.current) {
+          const error = new Error("interrupted");
+          error.code = "INTERRUPTED";
+          throw error;
         }
-        let shouldWait = false;
-        const results = [];
-        let batchPreferredWaitTarget = null;
-        const assertNotInterrupted = () => {
-          if (executionToken !== activeExecutionTokenRef.current || skipRequestedRef.current) {
-            const error = new Error("interrupted");
-            error.code = "INTERRUPTED";
-            throw error;
-          }
-        };
-        const resolveTargetElement2 = async (params = {}, fallbackStep) => {
-          const fallbackHints = fallbackStep?.element ?? null;
-          return retryLookup({
-            timeoutMs: Math.max(0, Number(params.timeoutMs ?? 1800)),
-            pollMs: Math.max(50, Number(params.pollMs ?? 120)),
-            onRetry: () => {
-              assertNotInterrupted();
-            },
-            resolve: async () => {
-              let targetEl = null;
-              if (params.uid) {
-                const { getElementByUid: getElementByUid2 } = await Promise.resolve().then(() => (init_aom(), aom_exports));
-                targetEl = getElementByUid2(params.uid);
-              }
-              if (!targetEl) {
-                targetEl = resolveElementFromHints({
-                  fingerprint: params.fingerprint ?? fallbackHints?.fingerprint,
-                  testId: params.testId ?? fallbackHints?.testId,
-                  textContaining: params.textContaining ?? fallbackHints?.textContaining
-                }, fallbackStep, tagStore);
-              }
-              return targetEl;
-            }
-          });
-        };
-        const executeOne = async (action) => {
-          assertNotInterrupted();
-          console.log("[TourClient] Executing action:", action?.type, action?.params ? JSON.stringify(action.params).slice(0, 120) : "");
-          const currentStep = tourRef.current?.steps?.[stepIndexRef.current] ?? null;
-          const executeTimeline = async (params = {}) => {
-            const segments = Array.isArray(params.segments) ? params.segments : [];
-            for (let index = 0; index < segments.length; index += 1) {
-              assertNotInterrupted();
-              const segment = segments[index];
-              const segmentText = (segment?.text ?? "").trim();
-              const segmentDelayMs = Math.max(0, Number(segment?.delayMs ?? 0));
-              const events = Array.isArray(segment?.events) ? segment.events : [];
-              if (segmentDelayMs > 0) {
-                await new Promise((resolve) => setTimeout(resolve, segmentDelayMs));
-              }
-              if (segment?.gate?.type === "user_action" && segment.gate.target && segment.gate.event) {
-                const gateTarget = await resolveTargetElement2(segment.gate.target, currentStep);
-                if (!gateTarget) {
-                  throw new Error(`timeline gate target not found for ${segment.gate.event}`);
-                }
-                await waitForUserAction(gateTarget, segment.gate.event);
-              }
-              if (segmentText && showCaptionsRef.current && reviewModeRef.current) {
-                showCaption(segmentText);
-              }
-              const nextSegmentText = (segments[index + 1]?.text ?? "").trim();
-              const speechPromise = segmentText ? voice.speak(segmentText, tourRef.current?.voice?.ttsVoice, {
-                prefetchLeadMs: tourRef.current?.voice?.ttsPrefetchLeadMs ?? currentStep?.execution?.ttsPrefetchLeadMs ?? 2e3,
-                onNearEnd: nextSegmentText ? () => {
-                  void voice.prefetchSpeech(nextSegmentText, tourRef.current?.voice?.ttsVoice);
-                } : void 0
-              }) : Promise.resolve();
-              const eventsPromise = (async () => {
-                for (const event of events) {
-                  assertNotInterrupted();
-                  const delayMs = Math.max(0, Number(event?.delayMs ?? 0));
-                  if (delayMs > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, delayMs));
-                  }
-                  if (event?.action) {
-                    await executeOne(event.action);
-                  }
-                }
-              })();
-              await Promise.all([speechPromise, eventsPromise]);
-            }
-            if (params.removeHighlightAtEnd !== false) {
-              removeHighlight();
-            }
-            if (showCaptionsRef.current && reviewModeRef.current) {
-              removeCaption();
-            }
-            return !!params.waitForInput;
-          };
-          if (action.type === "speak") {
-            const text = action.params?.text ?? "";
-            if (!text.trim()) {
-              return { result: null };
+      };
+      const resolveTargetElement2 = async (params = {}, fallbackStep) => {
+        const fallbackHints = fallbackStep?.element ?? null;
+        return retryLookup({
+          timeoutMs: Math.max(0, Number(params.timeoutMs ?? 1800)),
+          pollMs: Math.max(50, Number(params.pollMs ?? 120)),
+          onRetry: () => {
+            assertNotInterrupted();
+          },
+          resolve: async () => {
+            let targetEl = null;
+            if (params.uid) {
+              const { getElementByUid: getElementByUid2 } = await Promise.resolve().then(() => (init_aom(), aom_exports));
+              targetEl = getElementByUid2(params.uid);
             }
-            if (showCaptionsRef.current && reviewModeRef.current) {
-              showCaption(text);
+            if (!targetEl) {
+              targetEl = resolveElementFromHints({
+                fingerprint: params.fingerprint ?? fallbackHints?.fingerprint,
+                testId: params.testId ?? fallbackHints?.testId,
+                textContaining: params.textContaining ?? fallbackHints?.textContaining
+              }, fallbackStep, tagStore);
             }
-            const settlePromise = voice.speak(text, tourRef.current?.voice?.ttsVoice, {
-              // Schedule narration immediately so the client keeps its speculative,
-              // low-latency behavior, but defer batch completion until playback settles.
-              waitForCompletion: false,
-              interrupt: action.params?.interrupt
-            });
-            return { result: text, settlePromise };
+            return targetEl;
           }
-          if (action.type === "play_timeline") {
-            const timelineShouldWait = await executeTimeline(action.params);
-            if (timelineShouldWait) shouldWait = true;
-            return { result: "timeline_executed" };
-          }
-          if (action.type === "highlight_element") {
-            const resolvedEl = await resolveTargetElement2(action.params, currentStep);
-            if (resolvedEl) {
-              if (isEditableWaitTarget(resolvedEl)) {
-                batchPreferredWaitTarget = resolveWaitTargetElement(resolvedEl);
+        });
+      };
+      const executeOne = async (action) => {
+        assertNotInterrupted();
+        console.log("[TourClient] Executing action:", action?.type, action?.params ? JSON.stringify(action.params).slice(0, 120) : "");
+        const currentStep = tourRef.current?.steps?.[stepIndexRef.current] ?? null;
+        const executeTimeline = async (params = {}) => {
+          const segments = Array.isArray(params.segments) ? params.segments : [];
+          for (let index = 0; index < segments.length; index += 1) {
+            assertNotInterrupted();
+            const segment = segments[index];
+            const segmentText = (segment?.text ?? "").trim();
+            const segmentDelayMs = Math.max(0, Number(segment?.delayMs ?? 0));
+            const events = Array.isArray(segment?.events) ? segment.events : [];
+            if (segmentDelayMs > 0) {
+              await new Promise((resolve) => setTimeout(resolve, segmentDelayMs));
+            }
+            if (segment?.gate?.type === "user_action" && segment.gate.target && segment.gate.event) {
+              const gateTarget = await resolveTargetElement2(segment.gate.target, currentStep);
+              if (!gateTarget) {
+                throw new Error(`timeline gate target not found for ${segment.gate.event}`);
               }
-              showHighlight(resolvedEl, action.params?.label || action.label);
-              resolvedEl.scrollIntoView({ behavior: "smooth", block: "nearest" });
-              return { result: "highlighted" };
+              await waitForUserAction(gateTarget, segment.gate.event);
             }
-            if (!action.params?.optional) {
-              throw new Error(
-                `highlight_element target not found (${action.params?.uid || action.params?.testId || action.params?.fingerprint || action.params?.textContaining || currentStep?.element?.testId || currentStep?.element?.fingerprint || currentStep?.element?.textContaining || "unknown target"})`
-              );
+            if (segmentText && showCaptionsRef.current && reviewModeRef.current) {
+              showCaption(segmentText);
             }
-            return { result: "highlight_optional_miss" };
+            const nextSegmentText = (segments[index + 1]?.text ?? "").trim();
+            const speechPromise = segmentText ? voice.speak(segmentText, tourRef.current?.voice?.ttsVoice, {
+              prefetchLeadMs: tourRef.current?.voice?.ttsPrefetchLeadMs ?? currentStep?.execution?.ttsPrefetchLeadMs ?? 2e3,
+              onNearEnd: nextSegmentText ? () => {
+                void voice.prefetchSpeech(nextSegmentText, tourRef.current?.voice?.ttsVoice);
+              } : void 0
+            }) : Promise.resolve();
+            const eventsPromise = (async () => {
+              for (const event of events) {
+                assertNotInterrupted();
+                const delayMs = Math.max(0, Number(event?.delayMs ?? 0));
+                if (delayMs > 0) {
+                  await new Promise((resolve) => setTimeout(resolve, delayMs));
+                }
+                if (event?.action) {
+                  await executeOne(event.action);
+                }
+              }
+            })();
+            await Promise.all([speechPromise, eventsPromise]);
           }
-          if (action.type === "remove_highlight") {
+          if (params.removeHighlightAtEnd !== false) {
             removeHighlight();
-            return { result: "highlight_removed" };
           }
-          if (action.type === "click_element") {
-            const targetEl = await resolveTargetElement2(action.params, currentStep);
-            if (!targetEl) {
-              if (action.params?.optional) return { result: "click_optional_miss" };
-              throw new Error(
-                `click_element target not found (${action.params?.uid || action.params?.testId || action.params?.fingerprint || action.params?.textContaining || currentStep?.element?.testId || currentStep?.element?.fingerprint || currentStep?.element?.textContaining || "unknown target"})`
-              );
-            }
-            removeHighlight();
-            await performInteractiveClick(targetEl);
-            const { waitForDomSettle: waitForDomSettleClick } = await Promise.resolve().then(() => (init_dom_sync(), dom_sync_exports));
-            await waitForDomSettleClick({ timeoutMs: 3e3, debounceMs: 300 });
-            return { result: "clicked" };
+          if (showCaptionsRef.current && reviewModeRef.current) {
+            removeCaption();
           }
-          if (action.type === "fill_input") {
-            const targetEl = await resolveTargetElement2(action.params, currentStep);
-            if (!targetEl) {
-              throw new Error(
-                `fill_input target not found (${action.params?.uid || action.params?.testId || action.params?.fingerprint || action.params?.textContaining || currentStep?.element?.testId || currentStep?.element?.fingerprint || currentStep?.element?.textContaining || "unknown target"})`
-              );
-            }
-            const value = typeof action.params?.value === "string" ? action.params.value : "";
-            batchPreferredWaitTarget = resolveWaitTargetElement(targetEl);
-            await performInteractiveFill(targetEl, value);
-            return { result: value };
+          return !!params.waitForInput;
+        };
+        if (action.type === "speak") {
+          const text = action.params?.text ?? "";
+          if (!text.trim()) {
+            return { result: null };
           }
-          if (action.type === "take_screenshot") {
-            const html2canvasModule = await import("html2canvas");
-            const html2canvas2 = html2canvasModule.default;
-            const canvas = await html2canvas2(document.body, {
-              useCORS: true,
-              allowTaint: true,
-              scale: Math.min(window.devicePixelRatio, 2),
-              width: window.innerWidth,
-              height: window.innerHeight,
-              x: window.scrollX,
-              y: window.scrollY,
-              logging: false
-            });
-            return { result: canvas.toDataURL("image/png") };
+          if (showCaptionsRef.current && reviewModeRef.current) {
+            showCaption(text);
           }
-          if (action.type === "navigate_to_url") {
-            const nextUrl = typeof action.params?.url === "string" ? action.params.url : "";
-            if (!nextUrl) {
-              throw new Error("navigate_to_url missing url");
+          const settlePromise = voice.speak(text, tourRef.current?.voice?.ttsVoice, {
+            // Schedule narration immediately so the client keeps its speculative,
+            // low-latency behavior, but defer batch completion until playback settles.
+            waitForCompletion: false,
+            interrupt: action.params?.interrupt
+          });
+          return { result: text, settlePromise };
+        }
+        if (action.type === "play_timeline") {
+          const timelineShouldWait = await executeTimeline(action.params);
+          if (timelineShouldWait) shouldWait = true;
+          return { result: "timeline_executed" };
+        }
+        if (action.type === "highlight_element") {
+          const resolvedEl = await resolveTargetElement2(action.params, currentStep);
+          if (resolvedEl) {
+            if (isEditableWaitTarget(resolvedEl)) {
+              batchPreferredWaitTarget = resolveWaitTargetElement(resolvedEl);
             }
-            await navigateToTourUrl(nextUrl);
-            const { waitForDomSettle: waitForDomSettleNav } = await Promise.resolve().then(() => (init_dom_sync(), dom_sync_exports));
-            await waitForDomSettleNav({ timeoutMs: 3e3, debounceMs: 300 });
-            return { result: nextUrl };
+            showHighlight(resolvedEl, action.params?.label || action.label);
+            resolvedEl.scrollIntoView({ behavior: "smooth", block: "nearest" });
+            return { result: "highlighted" };
           }
-          if (action.type === "execute_agent_action") {
-            const agentSocketId = socketIdRef.current ?? socketRef.current?.id;
-            if (!agentSocketId) {
-              throw new Error("No socketId available for execute_agent_action");
-            }
-            const url = getAgentCommandUrl(serverUrl, commandUrlRef.current);
-            const res = await fetch(url, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({
-                command: action.params?.command,
-                socketId: agentSocketId
-              })
-            });
-            if (!res.ok) {
-              throw new Error(`execute_agent_action failed: ${await res.text()}`);
-            }
-            if (action.params?.wait !== false) {
-              await res.json();
-            }
-            const { waitForDomSettle: waitForDomSettle2 } = await Promise.resolve().then(() => (init_dom_sync(), dom_sync_exports));
-            await waitForDomSettle2({ timeoutMs: 3e3, debounceMs: 300 });
-            await syncAOM();
-            return { result: action.params?.command ?? "executed" };
+          if (!action.params?.optional) {
+            throw new Error(
+              `highlight_element target not found (${action.params?.uid || action.params?.testId || action.params?.fingerprint || action.params?.textContaining || currentStep?.element?.testId || currentStep?.element?.fingerprint || currentStep?.element?.textContaining || "unknown target"})`
+            );
           }
-          if (action.type === "wait_for_user_action") {
-            const targetEl = await resolveTargetElement2(action.params, currentStep);
-            if (!targetEl) {
-              throw new Error("wait_for_user_action target not found");
-            }
-            const eventName = action.params?.event ?? "click";
-            await waitForUserAction(targetEl, eventName);
-            return { result: `waited_for_${eventName}` };
+          return { result: "highlight_optional_miss" };
+        }
+        if (action.type === "remove_highlight") {
+          removeHighlight();
+          return { result: "highlight_removed" };
+        }
+        if (action.type === "click_element") {
+          const targetEl = await resolveTargetElement2(action.params, currentStep);
+          if (!targetEl) {
+            if (action.params?.optional) return { result: "click_optional_miss" };
+            throw new Error(
+              `click_element target not found (${action.params?.uid || action.params?.testId || action.params?.fingerprint || action.params?.textContaining || currentStep?.element?.testId || currentStep?.element?.fingerprint || currentStep?.element?.textContaining || "unknown target"})`
+            );
           }
-          if (action.type === "wait_for_input") {
-            shouldWait = true;
-            return { result: "waiting_for_input" };
+          removeHighlight();
+          await performInteractiveClick(targetEl);
+          const { waitForDomSettle: waitForDomSettleClick } = await Promise.resolve().then(() => (init_dom_sync(), dom_sync_exports));
+          await waitForDomSettleClick({ timeoutMs: 3e3, debounceMs: 300 });
+          return { result: "clicked" };
+        }
+        if (action.type === "fill_input") {
+          const targetEl = await resolveTargetElement2(action.params, currentStep);
+          if (!targetEl) {
+            throw new Error(
+              `fill_input target not found (${action.params?.uid || action.params?.testId || action.params?.fingerprint || action.params?.textContaining || currentStep?.element?.testId || currentStep?.element?.fingerprint || currentStep?.element?.textContaining || "unknown target"})`
+            );
           }
-          if (action.type === "end_tour") {
-            handleTourEnd();
-            return { result: "ended" };
+          const value = typeof action.params?.value === "string" ? action.params.value : "";
+          batchPreferredWaitTarget = resolveWaitTargetElement(targetEl);
+          await performInteractiveFill(targetEl, value);
+          return { result: value };
+        }
+        if (action.type === "take_screenshot") {
+          const html2canvasModule = await import("html2canvas");
+          const html2canvas2 = html2canvasModule.default;
+          const canvas = await html2canvas2(document.body, {
+            useCORS: true,
+            allowTaint: true,
+            scale: Math.min(window.devicePixelRatio, 2),
+            width: window.innerWidth,
+            height: window.innerHeight,
+            x: window.scrollX,
+            y: window.scrollY,
+            logging: false
+          });
+          return { result: canvas.toDataURL("image/png") };
+        }
+        if (action.type === "navigate_to_url") {
+          const nextUrl = typeof action.params?.url === "string" ? action.params.url : "";
+          if (!nextUrl) {
+            throw new Error("navigate_to_url missing url");
           }
-          console.warn("[TourClient] Unknown action type:", action?.type, "- skipping");
-          return { result: "unknown_action_skipped" };
-        };
-        try {
-          const resultsBuffer = new Array(payload.commands.length);
-          const pendingUIActions = [];
-          for (let commandIndex = 0; commandIndex < payload.commands.length; commandIndex += 1) {
-            const command = payload.commands[commandIndex];
-            assertNotInterrupted();
-            const isTerminal = isTerminalAction(command);
-            if (isTerminal) {
-              await Promise.all(pendingUIActions);
-              pendingUIActions.length = 0;
-            }
-            const executionPromise = (async () => {
-              const execution = await executeOne(command);
-              await execution.settlePromise;
-              resultsBuffer[commandIndex] = { type: command.type, success: true, result: execution.result };
-            })();
-            if (isTerminal) {
-              await executionPromise;
-            } else {
-              pendingUIActions.push(executionPromise);
-            }
+          await navigateToTourUrl(nextUrl);
+          const { waitForDomSettle: waitForDomSettleNav } = await Promise.resolve().then(() => (init_dom_sync(), dom_sync_exports));
+          await waitForDomSettleNav({ timeoutMs: 3e3, debounceMs: 300 });
+          return { result: nextUrl };
+        }
+        if (action.type === "execute_agent_action") {
+          const agentSocketId = socketIdRef.current ?? socketRef.current?.id;
+          if (!agentSocketId) {
+            throw new Error("No socketId available for execute_agent_action");
           }
-          await Promise.all(pendingUIActions);
-          resultsBuffer.forEach((res) => {
-            if (res) results.push(res);
+          const url = getAgentCommandUrl(serverUrl, commandUrlRef.current);
+          const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              command: action.params?.command,
+              socketId: agentSocketId
+            })
           });
+          if (!res.ok) {
+            throw new Error(`execute_agent_action failed: ${await res.text()}`);
+          }
+          if (action.params?.wait !== false) {
+            await res.json();
+          }
+          const { waitForDomSettle: waitForDomSettle2 } = await Promise.resolve().then(() => (init_dom_sync(), dom_sync_exports));
+          await waitForDomSettle2({ timeoutMs: 3e3, debounceMs: 300 });
           await syncAOM();
-        } catch (err) {
-          commandInFlightRef.current = false;
-          const interrupted = err?.code === "INTERRUPTED" || String(err) === "Error: interrupted";
-          if (interrupted) {
-            if (reviewModeRef.current && activeTourId && activePreviewRunId) {
-              void logPreviewEvent(serverUrl, toursApiBaseRef.current, activeTourId, activePreviewRunId, websiteId, {
-                stepOrder: stepIndexRef.current,
-                eventType: "command_batch_interrupted",
-                payload: {
-                  commandBatchId,
-                  partialResults: results
-                },
-                currentStepOrder: stepIndexRef.current
-              });
-            }
-            socket.emit("tour:action_result", {
-              success: true,
-              interrupted: true,
-              results,
-              commandBatchId,
-              runId: runIdRef.current,
-              turnId: turnIdRef.current
-            });
-            clearCommandBatchId();
-            return;
+          return { result: action.params?.command ?? "executed" };
+        }
+        if (action.type === "wait_for_user_action") {
+          const targetEl = await resolveTargetElement2(action.params, currentStep);
+          if (!targetEl) {
+            throw new Error("wait_for_user_action target not found");
+          }
+          const eventName = action.params?.event ?? "click";
+          await waitForUserAction(targetEl, eventName);
+          return { result: `waited_for_${eventName}` };
+        }
+        if (action.type === "wait_for_input") {
+          shouldWait = true;
+          return { result: "waiting_for_input" };
+        }
+        if (action.type === "end_tour") {
+          handleTourEnd();
+          return { result: "ended" };
+        }
+        console.warn("[TourClient] Unknown action type:", action?.type, "- skipping");
+        return { result: "unknown_action_skipped" };
+      };
+      try {
+        const resultsBuffer = new Array(payload.commands.length);
+        const pendingUIActions = [];
+        for (let commandIndex = 0; commandIndex < payload.commands.length; commandIndex += 1) {
+          const command = payload.commands[commandIndex];
+          assertNotInterrupted();
+          const isTerminal = isTerminalAction(command);
+          if (isTerminal) {
+            await Promise.all(pendingUIActions);
+            pendingUIActions.length = 0;
           }
-          console.error("[TourClient] Command batch execution failed:", err);
+          const executionPromise = (async () => {
+            const execution = await executeOne(command);
+            await execution.settlePromise;
+            resultsBuffer[commandIndex] = { type: command.type, success: true, result: execution.result };
+          })();
+          if (isTerminal) {
+            await executionPromise;
+          } else {
+            pendingUIActions.push(executionPromise);
+          }
+        }
+        await Promise.all(pendingUIActions);
+        resultsBuffer.forEach((res) => {
+          if (res) results.push(res);
+        });
+        await syncAOM();
+      } catch (err) {
+        commandInFlightRef.current = false;
+        const interrupted = err?.code === "INTERRUPTED" || String(err) === "Error: interrupted";
+        if (interrupted) {
           if (reviewModeRef.current && activeTourId && activePreviewRunId) {
             void logPreviewEvent(serverUrl, toursApiBaseRef.current, activeTourId, activePreviewRunId, websiteId, {
               stepOrder: stepIndexRef.current,
-              eventType: "command_batch_failed",
+              eventType: "command_batch_interrupted",
               payload: {
                 commandBatchId,
-                error: String(err),
                 partialResults: results
               },
-              status: "active",
               currentStepOrder: stepIndexRef.current
             });
           }
-          socket.emit("tour:action_result", {
-            success: false,
-            reason: "execution_error",
-            error: String(err),
+          emitIfOpen("tour:action_result", {
+            success: true,
+            interrupted: true,
             results,
             commandBatchId,
             runId: runIdRef.current,
@@ -3603,108 +3593,82 @@ function useTourPlayback({
           clearCommandBatchId();
           return;
         }
-        commandInFlightRef.current = false;
-        if (shouldWait && !skipRequestedRef.current) {
-          const currentStep = tourRef.current?.steps?.[stepIndexRef.current] ?? null;
-          const waitCondition = currentStep?.onboarding?.waitCondition;
-          const waitTargetHints = waitCondition?.target ?? currentStep?.onboarding?.waitTarget ?? currentStep?.element;
-          const waitEvent = waitCondition?.event ?? currentStep?.onboarding?.expectedUserAction ?? "input";
-          const inputLikeWait = isInputLikeWait(waitEvent, currentStep);
-          let manualWaitPromise = null;
-          let manualWaitKind = null;
-          const highlightedWaitTarget = lastHighlightTarget ? resolveWaitTargetElement(lastHighlightTarget) : null;
-          const preferredWaitTarget = inputLikeWait ? batchPreferredWaitTarget ?? highlightedWaitTarget : highlightedWaitTarget;
-          runCleanup(pendingManualWaitCleanupRef.current);
-          pendingManualWaitCleanupRef.current = null;
-          if (waitTargetHints) {
-            let manualWaitTarget = await resolveTargetElement2(waitTargetHints, currentStep);
-            if (inputLikeWait && preferredWaitTarget && manualWaitTarget && manualWaitTarget !== preferredWaitTarget && !isEditableWaitTarget(manualWaitTarget) && isEditableWaitTarget(preferredWaitTarget)) {
-              manualWaitTarget = preferredWaitTarget;
-              console.log("[TourClient] wait_for_input: preferring current editable target over hinted step target", manualWaitTarget);
-            }
-            if (manualWaitTarget) {
-              const manualWait = createManualWaitForTarget(manualWaitTarget, waitEvent, currentStep);
-              manualWaitPromise = manualWait.promise;
-              manualWaitKind = manualWait.kind;
-              pendingManualWaitCleanupRef.current = manualWait.cleanup;
-            }
+        console.error("[TourClient] Command batch execution failed:", err);
+        if (reviewModeRef.current && activeTourId && activePreviewRunId) {
+          void logPreviewEvent(serverUrl, toursApiBaseRef.current, activeTourId, activePreviewRunId, websiteId, {
+            stepOrder: stepIndexRef.current,
+            eventType: "command_batch_failed",
+            payload: {
+              commandBatchId,
+              error: String(err),
+              partialResults: results
+            },
+            status: "active",
+            currentStepOrder: stepIndexRef.current
+          });
+        }
+        emitIfOpen("tour:action_result", {
+          success: false,
+          reason: "execution_error",
+          error: String(err),
+          results,
+          commandBatchId,
+          runId: runIdRef.current,
+          turnId: turnIdRef.current
+        });
+        clearCommandBatchId();
+        return;
+      }
+      commandInFlightRef.current = false;
+      if (shouldWait && !skipRequestedRef.current) {
+        const currentStep = tourRef.current?.steps?.[stepIndexRef.current] ?? null;
+        const waitCondition = currentStep?.onboarding?.waitCondition;
+        const waitTargetHints = waitCondition?.target ?? currentStep?.onboarding?.waitTarget ?? currentStep?.element;
+        const waitEvent = waitCondition?.event ?? currentStep?.onboarding?.expectedUserAction ?? "input";
+        const inputLikeWait = isInputLikeWait(waitEvent, currentStep);
+        let manualWaitPromise = null;
+        let manualWaitKind = null;
+        const highlightedWaitTarget = lastHighlightTarget ? resolveWaitTargetElement(lastHighlightTarget) : null;
+        const preferredWaitTarget = inputLikeWait ? batchPreferredWaitTarget ?? highlightedWaitTarget : highlightedWaitTarget;
+        runCleanup(pendingManualWaitCleanupRef.current);
+        pendingManualWaitCleanupRef.current = null;
+        if (waitTargetHints) {
+          let manualWaitTarget = await resolveTargetElement2(waitTargetHints, currentStep);
+          if (inputLikeWait && preferredWaitTarget && manualWaitTarget && manualWaitTarget !== preferredWaitTarget && !isEditableWaitTarget(manualWaitTarget) && isEditableWaitTarget(preferredWaitTarget)) {
+            manualWaitTarget = preferredWaitTarget;
+            console.log("[TourClient] wait_for_input: preferring current editable target over hinted step target", manualWaitTarget);
           }
-          if (!manualWaitPromise && preferredWaitTarget) {
-            const manualWait = createManualWaitForTarget(preferredWaitTarget, waitEvent, currentStep);
+          if (manualWaitTarget) {
+            const manualWait = createManualWaitForTarget(manualWaitTarget, waitEvent, currentStep);
             manualWaitPromise = manualWait.promise;
             manualWaitKind = manualWait.kind;
             pendingManualWaitCleanupRef.current = manualWait.cleanup;
-            console.log("[TourClient] wait_for_input: using current editable target as fallback wait target", preferredWaitTarget);
           }
-          if (!manualWaitPromise && inputLikeWait) {
-            const firstInput = document.querySelector(
-              'input:not([type="hidden"]):not([disabled]), textarea:not([disabled]), [contenteditable="true"], [role="textbox"]'
-            );
-            if (firstInput) {
-              const manualWait = createManualWaitForTarget(firstInput, waitEvent, currentStep);
-              manualWaitPromise = manualWait.promise;
-              manualWaitKind = manualWait.kind;
-              pendingManualWaitCleanupRef.current = manualWait.cleanup;
-              console.log("[TourClient] wait_for_input: no target found, falling back to first visible editable element", firstInput);
-            }
-          }
-          setPlaybackState(manualWaitKind ? "waiting_input" : "waiting_voice");
-          if (reviewModeRef.current && activeTourId && activePreviewRunId) {
-            void logPreviewEvent(serverUrl, toursApiBaseRef.current, activeTourId, activePreviewRunId, websiteId, {
-              stepOrder: stepIndexRef.current,
-              eventType: "waiting_for_input",
-              payload: {
-                commandBatchId,
-                results
-              },
-              currentStepOrder: stepIndexRef.current
-            });
+        }
+        if (!manualWaitPromise && preferredWaitTarget) {
+          const manualWait = createManualWaitForTarget(preferredWaitTarget, waitEvent, currentStep);
+          manualWaitPromise = manualWait.promise;
+          manualWaitKind = manualWait.kind;
+          pendingManualWaitCleanupRef.current = manualWait.cleanup;
+          console.log("[TourClient] wait_for_input: using current editable target as fallback wait target", preferredWaitTarget);
+        }
+        if (!manualWaitPromise && inputLikeWait) {
+          const firstInput = document.querySelector(
+            'input:not([type="hidden"]):not([disabled]), textarea:not([disabled]), [contenteditable="true"], [role="textbox"]'
+          );
+          if (firstInput) {
+            const manualWait = createManualWaitForTarget(firstInput, waitEvent, currentStep);
+            manualWaitPromise = manualWait.promise;
+            manualWaitKind = manualWait.kind;
+            pendingManualWaitCleanupRef.current = manualWait.cleanup;
+            console.log("[TourClient] wait_for_input: no target found, falling back to first visible editable element", firstInput);
           }
-          socket.emit("tour:action_result", {
-            success: true,
-            waitingForInput: true,
-            results,
-            commandBatchId,
-            runId: runIdRef.current,
-            turnId: turnIdRef.current
-          });
-          clearCommandBatchId();
-          const voiceOrTextWaitPromise = new Promise((resolve) => {
-            if (pendingInputBufRef.current) {
-              const flushed = pendingInputBufRef.current;
-              pendingInputBufRef.current = null;
-              resolve(flushed);
-              return;
-            }
-            voiceInputResolveRef.current = (text) => {
-              voiceInputResolveRef.current = null;
-              resolve(text);
-            };
-          });
-          Promise.race([voiceOrTextWaitPromise, manualWaitPromise].filter(Boolean)).then(async (userText) => {
-            runCleanup(pendingManualWaitCleanupRef.current);
-            pendingManualWaitCleanupRef.current = null;
-            voiceInputResolveRef.current = null;
-            setPlaybackState("executing");
-            const transcript = userText.trim();
-            if (!transcript) {
-              return;
-            }
-            const { waitForDomSettle: waitForDomSettle2 } = await Promise.resolve().then(() => (init_dom_sync(), dom_sync_exports));
-            await waitForDomSettle2({ timeoutMs: 1500, debounceMs: 200 });
-            await syncAOM();
-            socket.emit("tour:user_input", {
-              transcript,
-              runId: runIdRef.current,
-              turnId: turnIdRef.current
-            });
-          });
-          return;
         }
+        setPlaybackState(manualWaitKind ? "waiting_input" : "waiting_voice");
         if (reviewModeRef.current && activeTourId && activePreviewRunId) {
           void logPreviewEvent(serverUrl, toursApiBaseRef.current, activeTourId, activePreviewRunId, websiteId, {
             stepOrder: stepIndexRef.current,
-            eventType: "command_batch_completed",
+            eventType: "waiting_for_input",
             payload: {
               commandBatchId,
               results
@@ -3712,101 +3676,169 @@ function useTourPlayback({
             currentStepOrder: stepIndexRef.current
           });
         }
-        socket.emit("tour:action_result", {
+        emitIfOpen("tour:action_result", {
           success: true,
+          waitingForInput: true,
           results,
           commandBatchId,
           runId: runIdRef.current,
           turnId: turnIdRef.current
         });
         clearCommandBatchId();
-      });
-      socket.on("tour:start", async (tourData) => {
-        if (isActiveRef.current) return;
-        runIdRef.current = typeof tourData.runId === "number" ? tourData.runId : runIdRef.current;
-        const tour = tourData.tourContext ?? tourRef.current;
-        if (tour?.type && tour.type !== experienceType) {
-          console.log(`[TourClient] Ignoring ${tour.type} start (this hook is for ${experienceType})`);
-          return;
-        }
-        skipRequestedRef.current = false;
-        const total = tourData.totalSteps ?? tour?.steps?.length ?? 0;
-        isActiveRef.current = true;
-        setIsActive(true);
-        setActiveTour(tour ?? null);
-        tourRef.current = tour ?? null;
-        setTotalSteps(total);
-        stepIndexRef.current = 0;
-        setCurrentStepIndex(0);
-        setPlaybackState("intro");
-        if (reviewModeRef.current && tour?.id && previewRunIdRef.current) {
-          void logPreviewEvent(serverUrl, toursApiBaseRef.current, tour.id, previewRunIdRef.current, websiteId, {
-            stepOrder: 0,
-            eventType: "tour_started",
-            payload: {
-              totalSteps: total,
-              source: "sdk_test_preview"
-            },
-            currentStepOrder: 0
+        const voiceOrTextWaitPromise = new Promise((resolve) => {
+          if (pendingInputBufRef.current) {
+            const flushed = pendingInputBufRef.current;
+            pendingInputBufRef.current = null;
+            resolve(flushed);
+            return;
+          }
+          voiceInputResolveRef.current = (text) => {
+            voiceInputResolveRef.current = null;
+            resolve(text);
+          };
+        });
+        Promise.race([voiceOrTextWaitPromise, manualWaitPromise].filter(Boolean)).then(async (userText) => {
+          runCleanup(pendingManualWaitCleanupRef.current);
+          pendingManualWaitCleanupRef.current = null;
+          voiceInputResolveRef.current = null;
+          setPlaybackState("executing");
+          const transcript = userText.trim();
+          if (!transcript) {
+            return;
+          }
+          const { waitForDomSettle: waitForDomSettle2 } = await Promise.resolve().then(() => (init_dom_sync(), dom_sync_exports));
+          await waitForDomSettle2({ timeoutMs: 1500, debounceMs: 200 });
+          await syncAOM();
+          emitIfOpen("tour:user_input", {
+            transcript,
+            runId: runIdRef.current,
+            turnId: turnIdRef.current
           });
-        }
-        try {
-          const { generateMinifiedAOM: generateMinifiedAOM2 } = await Promise.resolve().then(() => (init_aom(), aom_exports));
-          const aom = generateMinifiedAOM2();
+        });
+        return;
+      }
+      if (reviewModeRef.current && activeTourId && activePreviewRunId) {
+        void logPreviewEvent(serverUrl, toursApiBaseRef.current, activeTourId, activePreviewRunId, websiteId, {
+          stepOrder: stepIndexRef.current,
+          eventType: "command_batch_completed",
+          payload: {
+            commandBatchId,
+            results
+          },
+          currentStepOrder: stepIndexRef.current
+        });
+      }
+      emitIfOpen("tour:action_result", {
+        success: true,
+        results,
+        commandBatchId,
+        runId: runIdRef.current,
+        turnId: turnIdRef.current
+      });
+      clearCommandBatchId();
+    });
+    socket.on("tour:start", async (tourData) => {
+      if (isActiveRef.current) return;
+      runIdRef.current = typeof tourData.runId === "number" ? tourData.runId : runIdRef.current;
+      const tour = tourData.tourContext ?? tourRef.current;
+      const expType = experienceTypeRef.current;
+      if (tour?.type && tour.type !== expType) {
+        console.log(`[TourClient] Ignoring ${tour.type} start (this hook is for ${expType})`);
+        return;
+      }
+      skipRequestedRef.current = false;
+      const total = tourData.totalSteps ?? tour?.steps?.length ?? 0;
+      isActiveRef.current = true;
+      setIsActive(true);
+      setActiveTour(tour ?? null);
+      tourRef.current = tour ?? null;
+      setTotalSteps(total);
+      stepIndexRef.current = 0;
+      setCurrentStepIndex(0);
+      setPlaybackState("intro");
+      if (reviewModeRef.current && tour?.id && previewRunIdRef.current) {
+        void logPreviewEvent(serverUrl, toursApiBaseRef.current, tour.id, previewRunIdRef.current, websiteId, {
+          stepOrder: 0,
+          eventType: "tour_started",
+          payload: {
+            totalSteps: total,
+            source: "sdk_test_preview"
+          },
+          currentStepOrder: 0
+        });
+      }
+      try {
+        const { generateMinifiedAOM: generateMinifiedAOM2 } = await Promise.resolve().then(() => (init_aom(), aom_exports));
+        const aom = generateMinifiedAOM2();
+        if (socketRef.current === socket && socket.connected) {
           socket.emit("tour:sync_dom", {
             url: window.location.pathname + window.location.search + window.location.hash,
             aom: aom.nodes,
             domSummary: captureDomSummary()
           });
-        } catch (e) {
-          console.warn("[TourClient] Initial DOM sync failed:", e);
         }
-      });
-      socket.on("tour:update", (payload) => {
-        const updatedTour = payload?.tourContext;
-        if (!updatedTour?.id || updatedTour.id !== tourRef.current?.id) {
-          return;
-        }
-        tourRef.current = updatedTour;
-        setActiveTour(updatedTour);
-        const nextTotal = payload.totalSteps ?? updatedTour.steps?.length ?? 0;
-        setTotalSteps(nextTotal);
-        if (typeof payload.currentStepIndex === "number") {
-          const clampedStepIndex = Math.max(0, Math.min(payload.currentStepIndex, Math.max(0, nextTotal - 1)));
-          stepIndexRef.current = clampedStepIndex;
-          setCurrentStepIndex(clampedStepIndex);
-          if (nextTotal > 0) {
-            onStepChangeRef.current?.(clampedStepIndex, nextTotal, updatedTour);
-          }
+      } catch (e) {
+        console.warn("[TourClient] Initial DOM sync failed:", e);
+      }
+    });
+    socket.on("tour:update", (payload) => {
+      const updatedTour = payload?.tourContext;
+      if (!updatedTour?.id || updatedTour.id !== tourRef.current?.id) {
+        return;
+      }
+      tourRef.current = updatedTour;
+      setActiveTour(updatedTour);
+      const nextTotal = payload.totalSteps ?? updatedTour.steps?.length ?? 0;
+      setTotalSteps(nextTotal);
+      if (typeof payload.currentStepIndex === "number") {
+        const clampedStepIndex = Math.max(0, Math.min(payload.currentStepIndex, Math.max(0, nextTotal - 1)));
+        stepIndexRef.current = clampedStepIndex;
+        setCurrentStepIndex(clampedStepIndex);
+        if (nextTotal > 0) {
+          onStepChangeRef.current?.(clampedStepIndex, nextTotal, updatedTour);
         }
-      });
-      socket.on("tour:end", () => {
-        setServerState((prev) => prev ? { ...prev, isActive: false, phase: "completed" } : prev);
-        handleTourEnd();
-      });
-      socket.on("tour:debug_log", (entry) => {
-        const isDev = devMode || process.env.NODE_ENV === "development" || typeof window !== "undefined" && window.MODELNEX_DEBUG;
-        if (isDev) {
-          console.log(`%c[ModelNex Tour] ${entry.type}`, "color: #3b82f6; font-weight: bold", entry);
-          if (typeof window !== "undefined") {
-            window.dispatchEvent(new CustomEvent("modelnex-debug", {
-              detail: { msg: `[Tour Timeline] ${entry.type}`, data: entry }
-            }));
-          }
+      }
+    });
+    socket.on("tour:end", () => {
+      setServerState((prev) => prev ? { ...prev, isActive: false, phase: "completed" } : prev);
+      handleTourEnd();
+    });
+    socket.on("tour:debug_log", (entry) => {
+      const isDev = devModeRef.current || process.env.NODE_ENV === "development" || typeof window !== "undefined" && window.MODELNEX_DEBUG;
+      if (isDev) {
+        console.log(`%c[ModelNex Tour] ${entry.type}`, "color: #3b82f6; font-weight: bold", entry);
+        if (typeof window !== "undefined") {
+          window.dispatchEvent(new CustomEvent("modelnex-debug", {
+            detail: { msg: `[Tour Timeline] ${entry.type}`, data: entry }
+          }));
         }
-      });
-      console.log("[ModelNex SDK] Tour playback initialized. Debug logs enabled:", devMode || process.env.NODE_ENV === "development");
+      }
     });
+    console.log("[ModelNex SDK] Tour playback initialized. Debug logs enabled:", devModeRef.current || process.env.NODE_ENV === "development");
     return () => {
-      if (socketRef.current) {
-        socketRef.current.disconnect();
-        socketRef.current = null;
+      const toClose = createdSocket ?? socketRef.current;
+      if (toClose) {
+        toClose.disconnect();
       }
+      createdSocket = null;
+      socketRef.current = null;
       setServerState(null);
       runIdRef.current = null;
       turnIdRef.current = null;
     };
-  }, [serverUrl, websiteId, userProfile, disabled, devMode, experienceType]);
+  }, [serverUrl, websiteId, disabled]);
+  (0, import_react12.useEffect)(() => {
+    if (disabled) return;
+    const s = socketRef.current;
+    const profile = userProfile;
+    if (!s?.connected || !websiteId || !profile?.userId) return;
+    const timer = setTimeout(() => {
+      if (s.connected) {
+        s.emit("tour:init", { websiteId, userId: profile.userId, userType: profile.type });
+      }
+    }, 150);
+    return () => clearTimeout(timer);
+  }, [disabled, websiteId, userProfile?.userId, userProfile?.type]);
   (0, import_react12.useEffect)(() => {
     if (!showCaptions || !isReviewMode) {
       removeCaption();
@@ -3830,11 +3862,13 @@ function useTourPlayback({
     if (!socketRef.current?.connected || !isActiveRef.current) return;
     const { generateMinifiedAOM: generateMinifiedAOM2 } = await Promise.resolve().then(() => (init_aom(), aom_exports));
     const aom = generateMinifiedAOM2();
-    socketRef.current.emit("tour:sync_dom", {
-      url: window.location.pathname + window.location.search + window.location.hash,
-      aom: aom.nodes,
-      domSummary: captureDomSummary()
-    });
+    if (socketRef.current?.connected) {
+      socketRef.current.emit("tour:sync_dom", {
+        url: window.location.pathname + window.location.search + window.location.hash,
+        aom: aom.nodes,
+        domSummary: captureDomSummary()
+      });
+    }
   }, []);
   const interruptExecution = (0, import_react12.useCallback)((transcript) => {
     if (!socketRef.current?.connected || !isActiveRef.current) return false;
@@ -3845,21 +3879,23 @@ function useTourPlayback({
     removeHighlight();
     removeCaption();
     voice.stopSpeaking();
-    socketRef.current.emit("tour:action_result", {
-      success: true,
-      interrupted: true,
-      transcript,
-      commandBatchId: activeCommandBatchIdRef.current,
-      runId: runIdRef.current,
-      turnId: turnIdRef.current
-    });
-    activeCommandBatchIdRef.current = null;
-    socketRef.current.emit("tour:user_input", {
-      transcript,
-      interrupted: true,
-      runId: runIdRef.current,
-      turnId: turnIdRef.current
-    });
+    if (socketRef.current?.connected) {
+      socketRef.current.emit("tour:action_result", {
+        success: true,
+        interrupted: true,
+        transcript,
+        commandBatchId: activeCommandBatchIdRef.current,
+        runId: runIdRef.current,
+        turnId: turnIdRef.current
+      });
+      activeCommandBatchIdRef.current = null;
+      socketRef.current.emit("tour:user_input", {
+        transcript,
+        interrupted: true,
+        runId: runIdRef.current,
+        turnId: turnIdRef.current
+      });
+    }
     setPlaybackState("thinking");
     return true;
   }, [voice]);
@@ -3977,11 +4013,13 @@ function useTourPlayback({
       previewRunIdRef.current = null;
     }
     tourRef.current = tour;
-    socketRef.current.emit("tour:request_start", {
-      tourId: tour.id,
-      previewRunId: previewRunIdRef.current,
-      tourContext: tour
-    });
+    if (socketRef.current?.connected) {
+      socketRef.current.emit("tour:request_start", {
+        tourId: tour.id,
+        previewRunId: previewRunIdRef.current,
+        tourContext: tour
+      });
+    }
   }, [serverUrl, websiteId]);
   (0, import_react12.useEffect)(() => {
     if (!enableAutoDiscovery) return;
@@ -5429,7 +5467,7 @@ function useVoice(serverUrl) {
       (async () => {
         try {
           const ioModule = await import("socket.io-client");
-          const io2 = ioModule.default || ioModule;
+          const io3 = ioModule.default || ioModule;
           const stream = await navigator.mediaDevices.getUserMedia({
             audio: {
               echoCancellation: true,
@@ -5451,7 +5489,7 @@ function useVoice(serverUrl) {
             audioBitsPerSecond: 128e3
           });
           mediaRecorderRef.current = recorder;
-          const socket = io2(serverUrl, {
+          const socket = io3(serverUrl, {
             path: "/socket.io",
             transports: resolveSocketIoTransports(serverUrl, "websocket-first")
           });
@@ -10972,7 +11010,7 @@ var ModelNexProvider = ({
       socketId,
       devMode
     }),
-    [serverUrl, commandUrl, registerAction, unregisterAction, activeAgentActions, stagingFields, highlightActions, studioMode, recordingMode, extractedElements, tagStore, chatMessages, websiteId, userProfile, toursApiBase, voiceMuted, socketId, devMode]
+    [serverUrl, commandUrl, registerAction, unregisterAction, activeAgentActions, stagingFields, highlightActions, studioMode, recordingMode, extractedElements, tagStore, chatMessages, websiteId, userProfile?.userId, userProfile?.type, userProfile?.isNewUser, toursApiBase, voiceMuted, socketId, devMode]
   );
   return import_react21.default.createElement(
     ModelNexContext.Provider,