@modelnex/sdk 0.1.2 → 0.5.5

package/README.md

@@ -1,6 +1,6 @@
 # @modelnex/sdk
 
-React SDK for ModelNex agent chat, tours, and guided onboarding.
+React SDK for ModelNex agent chat, tours, and workflows.
 
 ## Install
 
@@ -8,10 +8,21 @@ React SDK for ModelNex agent chat, tours, and guided onboarding.
 npm install @modelnex/sdk react react-dom zod
 ```
 
+## Unit Tests
+
+Run the SDK unit tests from the `sdk` package directory:
+
+```bash
+cd sdk
+npm test
+```
+
+The SDK test script builds `dist/` first, then runs the unit tests.
+
 ## Quick Start
 
 ```tsx
-import { ModelNexProvider, ModelNexChatBubble, ModelNexOnboardingPanel } from '@modelnex/sdk';
+import { ModelNexProvider, ModelNexChatBubble } from '@modelnex/sdk';
 
 export default function AppShell() {
   return (
@@ -28,25 +39,42 @@ export default function AppShell() {
     >
       <App />
       <ModelNexChatBubble appName="My Product" />
-      <ModelNexOnboardingPanel appName="My Product" />
     </ModelNexProvider>
   );
 }
 ```
 
-`websiteId` identifies the integration. `userProfile` is used for tour/onboarding targeting and completion tracking. `tourFacts.features` is used for `feature_unlocked` experiences.
+`websiteId` identifies the integration. `userProfile` is used for tour/workflow targeting and completion tracking. `tourFacts.features` is used for `feature_unlocked` experiences.
+
+## Tour Start Model
+
+ModelNex currently supports these automatic trigger types:
+
+- `first_visit`
+- `feature_unlocked`
+- `manual`
+
+Each tour or workflow can also configure:
+
+- `startPolicy`: `immediate_start` | `prompt_only` | `manual_only`
+- `notificationType`: `bubble_card` | `modal`
+
+Current behavior:
+
+- `prompt_only + bubble_card` shows an in-bubble prompt
+- `prompt_only + modal` shows a centered modal
+- `immediate_start` starts playback immediately
+- `manual_only` never auto-surfaces
 
 ## Main Exports
 
 | Export | Purpose |
 |--------|---------|
-| `ModelNexProvider` | Root provider for server connection, chat state, dev tools, tours, and onboarding |
-| `ModelNexChatBubble` | General-purpose assistant UI plus recording/review tools |
-| `ModelNexOnboardingPanel` | Dedicated customer-facing UI for `type: 'onboarding'` flows |
+| `ModelNexProvider` | Root provider for server connection, chat state, dev tools, tours, and workflows |
+| `ModelNexChatBubble` | Unified assistant UI for chat, voice tours, and workflows |
 | `useRunCommand` | Run agent commands from custom UI |
-| `useRegisterAction` | Register app actions the agent can execute |
 | `useTourPlayback` | Low-level playback hook for tours and shared experience runtime |
-| `useOnboardingPlayback` | Playback hook preconfigured for onboarding flows |
+| `useOnboardingPlayback` | Playback hook preconfigured for workflow playback |
 | `useExperiencePlayback` | Alias over the shared playback hook |
 | `useRecordingMode` | Low-level recorder hook for custom authoring UI |
 | `useActionHighlight` | Highlight actions currently being executed |
@@ -60,9 +88,9 @@ export default function AppShell() {
 | `serverUrl` | ModelNex server base URL. Defaults to `https://api.modelnex.io` |
 | `commandUrl` | Optional same-origin command proxy base |
 | `websiteId` | Tenant/integration identifier |
-| `userProfile` | End-user targeting data for tours/onboarding |
+| `userProfile` | End-user targeting data for tours/workflows |
 | `tourFacts` | Additional facts, currently used for feature-based eligibility |
-| `toursApiBase` | Same-origin API base for tour/onboarding fetches and test URLs |
+| `toursApiBase` | Same-origin API base for tour/workflow fetches and test URLs |
 | `devMode` | Enables recording/studio tooling for your internal users |
 
 ## Chat Bubble Props
@@ -73,14 +101,88 @@ export default function AppShell() {
 | `defaultCommand` | Fallback command when the input is empty |
 | `welcomeMessage` | Empty-state greeting |
 | `appName` | Product name used in narration and UI copy |
+| `agentName` | Name of the AI agent displayed in the header |
 | `onCommand` | Custom backend override for agent command handling |
 | `recordingExperienceType` | Save recordings as `'tour'` or `'onboarding'` |
 | `className` | Additional class name for the container |
+| `theme` | Custom theme overrides for the chat bubble and panel (`accentColor`, `panelWidth`, etc.) |
+
+## Configuration Examples
+
+Here are some real-world examples of how to configure the SDK.
+
+### Fully Customized Provider
+
+```tsx
+import { ModelNexProvider } from '@modelnex/sdk';
+
+export function AppShell({ children, currentUser }) {
+  return (
+    <ModelNexProvider
+      // Basic Setup
+      serverUrl="https://api.yourdomain.com/modelnex"
+      websiteId="prod_site_123"
+      
+      // Development and Proxy setup
+      devMode={process.env.NODE_ENV === 'development'}
+      commandUrl="/api/modelnex/command" // Proxies commands through your own API
+      toursApiBase="/api/tours" // Proxies tour fetches to avoid CORS
+      
+      // User Targeting for Tours & Workflows
+      userProfile={{
+        userId: currentUser.id,
+        isNewUser: currentUser.createdAt > Date.now() - 86400000 * 7, // 7 days
+        type: currentUser.role, // e.g. "admin", "viewer"
+      }}
+      
+      // Additional facts for Feature-Gated Tours
+      tourFacts={{
+        features: currentUser.enabledFeatures, // e.g. ["billing", "advanced_reporting"]
+      }}
+    >
+      {children}
+    </ModelNexProvider>
+  );
+}
+```
+
+### Themed Chat Bubble
+
+```tsx
+import { ModelNexChatBubble } from '@modelnex/sdk';
+
+export function ChatIntegration() {
+  return (
+    <ModelNexChatBubble 
+      // Branding & Copy
+      appName="Acme Corp Dashboard"
+      agentName="Acme Assistant"
+      welcomeMessage="Hi there! Ask me to navigate to a page or help you with your account."
+      placeholder="Type a command or ask a question..."
+      defaultCommand="Show me my recent activity"
+      
+      // Recording defaults
+      recordingExperienceType="onboarding" // Default is 'tour'
+      
+      // Visual Theme Customization
+      theme={{
+        accentColor: "#f59e0b", // Amber accent
+        accentForeground: "#ffffff",
+        panelWidth: "400px", // Wider panel
+        panelMaxHeight: "700px",
+        bubbleSize: "64px", // Larger bubble
+        borderRadius: "24px",
+        zIndex: 9999
+      }}
+    />
+  );
+}
+```
 
 ## Testing Flows
 
 - Force a tour with `?modelnex_test_tour=TOUR_ID`
-- Force onboarding with `?modelnex_test_onboarding=FLOW_ID`
+- Force a workflow with `?modelnex_test_workflow=FLOW_ID`
 - If you use a same-origin proxy, set `toursApiBase` so test fetches avoid CORS issues
 
 ## Custom UI

package/dist/aom-HDYNCIOY.mjs

@@ -0,0 +1,10 @@
+import {
+  clearAOMMap,
+  generateMinifiedAOM,
+  getElementByUid
+} from "./chunk-N65UEB6X.mjs";
+export {
+  clearAOMMap,
+  generateMinifiedAOM,
+  getElementByUid
+};

package/dist/{aom-J6NYMGDW.mjs → chunk-N65UEB6X.mjs}

@@ -62,8 +62,9 @@ function clearAOMMap() {
   uidMap.clear();
   nextUid = 1;
 }
+
 export {
-  clearAOMMap,
   generateMinifiedAOM,
-  getElementByUid
+  getElementByUid,
+  clearAOMMap
 };

package/dist/index.d.mts

@@ -1,9 +1,8 @@
 import React$1 from 'react';
-import { z } from 'zod';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
 type ExperienceType = 'tour' | 'onboarding';
-type TourStepType = 'narrate' | 'act' | 'ask_and_fill' | 'user_input' | 'ask_or_fill';
+type TourStepType = 'narrate' | 'act' | 'input' | 'ask_and_fill' | 'user_input' | 'ask_or_fill' | 'wait_then_act';
 type TourUserActionEvent = 'click' | 'input' | 'change' | 'blur';
 interface TourActionTarget {
     uid?: string;
@@ -58,7 +57,7 @@ interface TourRecordedClick {
     /** Visible text or placeholder captured at record time */
     textContaining: string;
 }
-type TourCaptureEventType = 'session_start' | 'route' | 'click' | 'input' | 'note';
+type TourCaptureEventType = 'session_start' | 'route' | 'hover' | 'click' | 'input' | 'note';
 interface TourCaptureEvent {
     id: string;
     type: TourCaptureEventType;
@@ -134,7 +133,7 @@ interface TourStep {
     /** Optional onboarding-specific step metadata */
     onboarding?: OnboardingStepMetadata;
 }
-type TourTrigger = 'first_visit' | 'feature_unlocked' | 'feature_unlock' | 'idle_on_empty_state' | 'return_visit' | 'new_feature' | 'manual';
+type TourTrigger = 'first_visit' | 'feature_launch' | 'feature_unlocked' | 'feature_unlock' | 'new_feature' | 'manual';
 type TourStartPolicy = 'immediate_start' | 'prompt_only' | 'manual_only';
 type TourNotificationType = 'bubble_card' | 'modal';
 interface TourVoiceConfig {
@@ -142,13 +141,21 @@ interface TourVoiceConfig {
     ttsVoice?: string;
     ttsPrefetchLeadMs?: number;
 }
+interface ExperienceModalConfig {
+    title?: string;
+    description?: string;
+    buttonText?: string;
+    cancelButtonText?: string;
+    backgroundColor?: string;
+    textColor?: string;
+}
 interface ExperiencePresentation {
-    launcher?: 'tour_bubble' | 'onboarding_bubble' | 'checklist' | 'none';
     theme?: {
         tone?: 'guide' | 'coach' | 'operator';
         accentColor?: string;
         icon?: string;
     };
+    modalConfig?: ExperienceModalConfig;
 }
 interface ExperienceGoal {
     primaryAction?: string;
@@ -171,6 +178,11 @@ interface Tour {
     goal?: ExperienceGoal;
     capture?: {
         experienceType?: ExperienceType;
+        instructions?: {
+            transcript?: string;
+            noteEvents?: TourCaptureEvent[];
+        };
+        notes?: RecordingStep[];
         onboardingHints?: {
             inferredWaitTargets?: number;
             inferredCompletionSignals?: number;
@@ -191,12 +203,8 @@ interface UserProfile {
     /** User ID for per-user completion state */
     userId?: string;
 }
-interface TourFacts {
-    /** Feature keys currently available to the user, used for feature_unlocked tours */
-    features?: string[];
-}
 /** Playback state machine states */
-type TourPlaybackState = 'idle' | 'intro' | 'executing' | 'thinking' | 'waiting_voice' | 'waiting_input' | 'complete';
+type TourPlaybackState = 'idle' | 'intro' | 'executing' | 'thinking' | 'waiting_voice' | 'waiting_input' | 'paused' | 'complete';
 /** Internal recording step being built */
 interface RecordingStep {
     order: number;
@@ -389,22 +397,6 @@ interface ChatMessage {
     debug?: AgentDebug;
 }
 
-interface UseRegisterActionOptions<T extends z.ZodTypeAny = z.ZodTypeAny> {
-    id: string;
-    description: string;
-    schema: T;
-    execute: (params: z.infer<T>) => unknown | Promise<unknown>;
-}
-/**
- * Register a custom action with the ModelNex agent.
- * Use this to add app-specific actions (e.g. navigation, domain operations).
- * The action is synced to the server with built-in actions and can be invoked by the agent.
- *
- * Must be used within ModelNexProvider.
- * Memoize schema (define outside component) and execute (useCallback) to avoid unnecessary re-registration.
- */
-declare function useRegisterAction<T extends z.ZodTypeAny = z.ZodTypeAny>(action: UseRegisterActionOptions<T>): void;
-
 interface UIStateProviderProps {
     children: React$1.ReactNode;
     /** Agent context id (default: "agent-ui-state") */
@@ -458,33 +450,36 @@ interface ModelNexChatBubbleProps {
     defaultCommand?: string;
     /** Additional class names for the container */
     className?: string;
-    /** Custom fetch - use your own inference/backend. Omit to use agent server from Provider. */
-    onCommand?: (command: string) => Promise<{
-        actionsExecuted?: number;
-        summary?: string;
-        nextSteps?: string[];
-        debug?: AgentDebug;
-        [key: string]: unknown;
-    }>;
     /** Welcome message when chat is empty */
     welcomeMessage?: string;
+    /** Name of the AI agent displayed in the header */
+    agentName?: string;
     /** Display name of the app — used in tour intro narration */
     appName?: string;
-    /** Save recorded flows as tours or onboarding without changing the recorder UX */
-    recordingExperienceType?: ExperienceType;
+    /** Custom theme overrides */
+    theme?: {
+        accentColor?: string;
+        accentForeground?: string;
+        panelWidth?: string;
+        panelMaxHeight?: string;
+        bubbleSize?: string;
+        bubbleIconSize?: string;
+        borderRadius?: string;
+        zIndex?: number;
+    };
 }
 /**
  * Chat interface for natural language commands.
  * Shows conversation history; on exit, the agent summarizes what it did and suggests next steps.
  * Use within ModelNexProvider. Omit to use your own UI with useRunCommand.
  */
-declare function ModelNexChatBubble({ placeholder, defaultCommand, className, onCommand, welcomeMessage, appName, recordingExperienceType, }: ModelNexChatBubbleProps): react_jsx_runtime.JSX.Element;
+declare function ModelNexChatBubble({ placeholder, defaultCommand, className, welcomeMessage, agentName, appName, theme, }: ModelNexChatBubbleProps): React$1.ReactPortal | null;
 
 interface ModelNexOnboardingPanelProps {
     appName?: string;
     title?: string;
 }
-declare function ModelNexOnboardingPanel({ appName, title, }: ModelNexOnboardingPanelProps): react_jsx_runtime.JSX.Element | null;
+declare function ModelNexOnboardingPanel({ appName, title, }: ModelNexOnboardingPanelProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Toggle and read the action-highlight overlay state.
@@ -543,10 +538,14 @@ declare global {
     }
 }
 interface VoiceHook {
-    /** Speak text via Deepgram TTS (proxied through server). Uses WebRTC loopback for AEC when available. */
+    /** Speak text via Deepgram TTS (proxied through server). Uses WebRTC loopback for AEC when available.
+     * The returned promise always settles when the scheduled playback settles; callers can choose whether to await it.
+     */
     speak: (text: string, voiceId?: string, options?: {
         onNearEnd?: () => void;
         prefetchLeadMs?: number;
+        waitForCompletion?: boolean;
+        interrupt?: boolean;
     }) => Promise<void>;
     /** Stop any in-progress TTS playback immediately */
     stopSpeaking: () => void;
@@ -556,6 +555,8 @@ interface VoiceHook {
     startListening: (onResult: (transcript: string) => void, onInterruption?: (transcript: string) => void, onError?: (err: string) => void, options?: {
         continuous?: boolean;
         lang?: string;
+        onSpeechStarted?: () => void;
+        onInterimResult?: (transcript: string) => void;
     }) => void;
     /** Stop STT listening */
     stopListening: () => void;
@@ -569,6 +570,10 @@ interface VoiceHook {
 }
 declare function useVoice(serverUrl: string): VoiceHook;
 
+interface StartTourOptions {
+    reviewMode?: boolean;
+    reviewMetadata?: Record<string, unknown>;
+}
 interface TourPlaybackHook {
     /** Whether a tour is currently running */
     isActive: boolean;
@@ -590,8 +595,10 @@ interface TourPlaybackHook {
     reviewStatusMessage: string | null;
     /** Prompted tour awaiting user confirmation */
     pendingTour: Tour | null;
+    /** Latest server-authored state snapshot for this experience */
+    serverState: TourServerState | null;
     /** Start a specific tour manually */
-    startTour: (tour: Tour) => void;
+    startTour: (tour: Tour, options?: StartTourOptions) => void;
     /** Accept the currently pending prompt and start playback */
     acceptPendingTour: () => void;
     /** Dismiss the currently pending prompt */
@@ -600,6 +607,10 @@ interface TourPlaybackHook {
     advanceStep: () => void;
     /** Skip the entire tour */
     skipTour: () => void;
+    /** Explicitly pause the tour agent (for feedback/review) */
+    pauseTour: () => void;
+    /** Resume the tour agent after a pause */
+    resumeTour: () => void;
     /** Repeat current step narration */
     repeatStep: () => void;
     /** Handle a voice input during the tour */
@@ -609,6 +620,23 @@ interface TourPlaybackHook {
     /** Save a correction against the current preview step */
     submitReviewFeedback: (utterance: string, apply?: boolean) => Promise<void>;
 }
+interface TourServerState {
+    runId: number | null;
+    turnId: string | null;
+    stepIndex: number;
+    phase: string;
+    isActive: boolean;
+    isPaused: boolean;
+    awaitingUserInput: boolean;
+    pendingCommandId: string | null;
+    pendingCommandBatch: {
+        commandBatchId: string | null;
+        stepIndex: number | null;
+        turnId: string | null;
+    } | null;
+    currentUrl?: string | null;
+    reason?: string;
+}
 interface UseTourPlaybackOptions {
     serverUrl: string;
     /** Base URL for agent commands (e.g. /api/modelnex for same-origin). Default: serverUrl */
@@ -619,7 +647,6 @@ interface UseTourPlaybackOptions {
     socketId?: string | null;
     websiteId?: string;
     userProfile?: UserProfile;
-    tourFacts?: TourFacts;
     voice: VoiceHook;
     appName?: string;
     /** Pass the page's current state to the LLM agent */
@@ -634,8 +661,12 @@ interface UseTourPlaybackOptions {
     disabled?: boolean;
     /** Shared runtime, but allow a distinct product surface such as onboarding */
     experienceType?: ExperienceType;
+    /** Whether to show global floating captions (usually true when bubble is minimized, false when expanded) */
+    showCaptions?: boolean;
+    /** Disable internal pending prompt/query discovery when a higher-level controller owns it */
+    enableAutoDiscovery?: boolean;
 }
-declare function useTourPlayback({ serverUrl, commandUrl, toursApiBase, socketId, websiteId, userProfile, tourFacts, voice, appName, extractedElements, tagStore, onStepChange, onTourEnd, disabled, experienceType, }: UseTourPlaybackOptions): TourPlaybackHook;
+declare function useTourPlayback({ serverUrl, commandUrl, toursApiBase, socketId, websiteId, userProfile, voice, appName, extractedElements, tagStore, onStepChange, onTourEnd, disabled, experienceType, showCaptions, enableAutoDiscovery, }: UseTourPlaybackOptions): TourPlaybackHook;
 
 type ExperiencePlaybackHook = TourPlaybackHook;
 declare function useExperiencePlayback(...args: Parameters<typeof useTourPlayback>): TourPlaybackHook;
@@ -680,6 +711,7 @@ interface RecordingModeHook {
     continueRecording: () => void;
     undoLastStep: () => void;
     previewSteps: () => void;
+    prepareToStopRecording: () => void;
     stopRecording: (tourName: string, targetUserTypes: string[]) => Promise<string | null>;
     toggleVoiceCapture: () => void;
     /** Abandon recording — discard all steps and exit recording mode */
@@ -694,6 +726,27 @@ interface UseRecordingModeOptions {
     onPreview?: (steps: RecordingStep[]) => void;
     experienceType?: ExperienceType;
 }
+declare function buildRecordingCapturePayload({ experienceType, steps, captureEvents, capturedTranscript, }: {
+    experienceType?: ExperienceType;
+    steps?: RecordingStep[];
+    captureEvents?: TourCaptureEvent[];
+    capturedTranscript?: string;
+}): {
+    generation: {
+        mode: "capture_v1";
+        generatedAt: string;
+        eventCount: number;
+        noteCount: number;
+        generatedStepCount: number;
+    };
+    instructions?: {
+        noteEvents?: TourCaptureEvent[] | undefined;
+        transcript?: string | undefined;
+    } | undefined;
+    experienceType: ExperienceType;
+    events: TourCaptureEvent[];
+    notes: RecordingStep[];
+};
 declare function useRecordingMode({ serverUrl, toursApiBase, websiteId, voice, onPreview, experienceType, }: UseRecordingModeOptions): RecordingModeHook;
 
 interface TourProgressPanelProps {
@@ -734,11 +787,36 @@ interface RecordingOverlayProps {
 }
 declare function RecordingOverlay({ stepIndex, stepCount, captureEventCount, capturedTranscript, isVoiceCaptureActive, phase, pendingNarration, polishedNarration, isListening, onMarkStep, onToggleVoiceCapture, onElementSelected, onPageLevelStep, onStepTypeConfirmed, onStartNarration, onSubmitTextNarration, onNarrationApprove, onNarrationRedo, onNarrationEdit, onAddNextStep, onDoneRecording, onCancel, onCancelRecording, onStopRecording, }: RecordingOverlayProps): react_jsx_runtime.JSX.Element;
 
+declare function isAskDrivenInputStepType(stepType?: string | null): boolean;
+declare function isInteractiveInputStepType(stepType?: string | null): boolean;
+declare function isManualOnboardingStep(step?: Pick<TourStep, 'type' | 'onboarding'> | null): boolean;
+declare function buildRecordingStepGoal(stepType: TourStepType, selectedElement: {
+    label?: string;
+    textContaining?: string;
+} | null, recordedClicks?: Array<{
+    label?: string;
+}>): string | undefined;
+declare function inferOnboardingMetadataForStep(step: Pick<TourStep, 'type' | 'element' | 'goal' | 'ask'>): OnboardingStepMetadata | undefined;
+
+declare function shouldShowRecordingOverlay(phase: RecordingPhase): boolean;
+declare function isRecordingDraftGenerating(phase: RecordingPhase): boolean;
+declare function getRecordingDraftActionLabel(phase: RecordingPhase): string;
+declare function getRecordingDraftStatusMessage(phase: RecordingPhase, experienceType: ExperienceType): string;
+
+interface SavedDraftPreview {
+    id: string;
+    experienceType: ExperienceType;
+}
+type PreviewLaunchSource = 'standard' | 'query_param';
+declare function getPreviewQueryParamName(experienceType: ExperienceType): 'modelnex_test_tour' | 'modelnex_test_workflow';
+declare function buildDraftPreviewUrl(currentUrl: string, draft: SavedDraftPreview): string;
+declare function shouldPromptForPreviewStart(notificationType: TourNotificationType | undefined, _source: PreviewLaunchSource): boolean;
+declare function persistActiveDraftPreview(draft: SavedDraftPreview): void;
+declare function readActiveDraftPreview(): SavedDraftPreview | null;
+declare function clearActiveDraftPreview(experienceType?: ExperienceType): void;
+
 interface ModelNexProviderProps {
-    children: React$1.ReactNode;
-    serverUrl?: string;
-    /** Base URL for agent commands. Use same-origin path (e.g. /api/modelnex) to avoid CORS. Default: serverUrl */
-    commandUrl?: string;
+    children?: unknown;
     /** Identifier for the integrated website, for multi-tenancy */
     websiteId?: string;
     /**
@@ -748,13 +826,6 @@ interface ModelNexProviderProps {
      * userId — used for per-user tour completion state
      */
     userProfile?: UserProfile;
-    /** Optional product facts used for feature-triggered tours */
-    tourFacts?: TourFacts;
-    /**
-     * Same-origin base for tour API (e.g. /api/modelnex/api).
-     * When set, ?modelnex_test_tour= fetches via this path to avoid CORS.
-     */
-    toursApiBase?: string;
     /**
      * Enable SDK dev tools unconditionally (tour recording, studio mode)
      */
@@ -762,4 +833,4 @@ interface ModelNexProviderProps {
 }
 declare const ModelNexProvider: React$1.FC<ModelNexProviderProps>;
 
-export { type AgentDebug, type AgentTraceLlmInput, type AgentTraceStep, type ChatMessage, type ExperienceGoal, type ExperiencePlaybackHook, type ExperiencePresentation, type ExperienceType, type ExtractedElement, ModelNexChatBubble, type ModelNexChatBubbleProps, ModelNexOnboardingPanel, type ModelNexOnboardingPanelProps, ModelNexProvider, type ModelNexProviderProps, type OnboardingPlaybackHook, type OnboardingStepMetadata, type RecordingModeHook, RecordingOverlay, type RunCommandResult, StudioOverlay, type TagData, type TagStore, type Tour, type TourFacts, type TourNotificationType, type TourPlaybackHook, type TourPlaybackState, TourProgressPanel, type TourStartPolicy, type TourStep, type TourStepType, type TourTrigger, UIStateProvider, type UseRegisterActionOptions, type UserProfile, type VoiceHook, extractInteractiveElements, generateFingerprint, useActionHighlight, useAgentViewport, useAutoExtract, useExperiencePlayback, useOnboardingPlayback, useRecordingMode, useRegisterAction, useRunCommand, useTagStore, useTourPlayback, useUIState, useViewportTrack, useVisibleIds, useVoice };
+export { type AgentDebug, type AgentTraceLlmInput, type AgentTraceStep, type ChatMessage, type ExperienceGoal, type ExperiencePlaybackHook, type ExperiencePresentation, type ExperienceType, type ExtractedElement, ModelNexChatBubble, type ModelNexChatBubbleProps, ModelNexOnboardingPanel, type ModelNexOnboardingPanelProps, ModelNexProvider, type ModelNexProviderProps, type OnboardingPlaybackHook, type OnboardingStepMetadata, type PreviewLaunchSource, type RecordingModeHook, RecordingOverlay, type RunCommandResult, type SavedDraftPreview, StudioOverlay, type TagData, type TagStore, type Tour, type TourNotificationType, type TourPlaybackHook, type TourPlaybackState, TourProgressPanel, type TourStartPolicy, type TourStep, type TourStepType, type TourTrigger, UIStateProvider, type UserProfile, type VoiceHook, buildDraftPreviewUrl, buildRecordingCapturePayload, buildRecordingStepGoal, clearActiveDraftPreview, extractInteractiveElements, generateFingerprint, getPreviewQueryParamName, getRecordingDraftActionLabel, getRecordingDraftStatusMessage, inferOnboardingMetadataForStep, isAskDrivenInputStepType, isInteractiveInputStepType, isManualOnboardingStep, isRecordingDraftGenerating, persistActiveDraftPreview, readActiveDraftPreview, shouldPromptForPreviewStart, shouldShowRecordingOverlay, useActionHighlight, useAgentViewport, useAutoExtract, useExperiencePlayback, useOnboardingPlayback, useRecordingMode, useRunCommand, useTagStore, useTourPlayback, useUIState, useViewportTrack, useVisibleIds, useVoice };