guideai-app 0.5.0 → 0.5.1-2

package/dist/__mocks__/fileMock.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: string;
+export = _exports;

package/dist/components/AnimatedSettingsItem.d.ts

@@ -5,5 +5,5 @@ interface AnimatedSettingsItemProps {
     children: React.ReactNode;
     React: typeof import('react');
 }
-declare const AnimatedSettingsItem: ({ visible, gap, isLast, children, React }: AnimatedSettingsItemProps) => import("react").JSX.Element;
+declare const AnimatedSettingsItem: ({ visible, gap, isLast, children, React, }: AnimatedSettingsItemProps) => import("react").JSX.Element;
 export default AnimatedSettingsItem;

package/dist/components/AudioConfigDialog.d.ts

@@ -0,0 +1,20 @@
+import { AudioConfig, StoredAudioConfig } from '../types/audioConfig.types';
+interface AudioConfigDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    initialConfig: StoredAudioConfig | null;
+    onApply: (config: AudioConfig, stored: StoredAudioConfig) => void;
+    hasRespondedWithAudio: boolean;
+    defaultMicLabel: string | null;
+    React: typeof import('react');
+    ReactDOM?: {
+        createPortal: (children: React.ReactNode, container: Element) => React.ReactNode;
+    };
+}
+declare const AudioConfigDialog: {
+    ({ isOpen, onClose, initialConfig, onApply, hasRespondedWithAudio, defaultMicLabel, React, ReactDOM, }: AudioConfigDialogProps): import("react").FunctionComponentElement<{
+        children?: import("react").ReactNode | undefined;
+    }> | null;
+    displayName: string;
+};
+export default AudioConfigDialog;

package/dist/components/ConfigButton.d.ts

@@ -0,0 +1,10 @@
+interface ConfigButtonProps {
+    onOpenConfig: () => void;
+    hasMic: boolean;
+    React: typeof import('react');
+}
+declare const ConfigButton: {
+    ({ onOpenConfig, hasMic, React }: ConfigButtonProps): import("react").JSX.Element;
+    displayName: string;
+};
+export default ConfigButton;

package/dist/components/Microphone.d.ts

@@ -8,6 +8,8 @@ interface MicrophoneProps {
     handleOnboardingComplete: () => void;
     handleOnboardingClose: () => void;
     isConnecting: boolean;
+    /** Message shown when connecting (e.g. "Initializing..." or "Retrying...") */
+    connectionMessage?: string | null;
     status: RecordingStatus;
     handleToggleConversation: () => void;
     showTranscript: boolean;
@@ -15,5 +17,5 @@ interface MicrophoneProps {
     isMuted: boolean;
     React: typeof import('react');
 }
-declare const Microphone: ({ componentRef, baseStyles, hasInteracted, popupPosition, showOnboarding, handleOnboardingComplete, handleOnboardingClose, isConnecting, status, handleToggleConversation, showTranscript, hasMic, isMuted, React }: MicrophoneProps) => import("react").JSX.Element;
+declare const Microphone: ({ componentRef, baseStyles, hasInteracted, popupPosition, showOnboarding, handleOnboardingComplete, handleOnboardingClose, isConnecting, connectionMessage, status, handleToggleConversation, showTranscript, hasMic, isMuted, React, }: MicrophoneProps) => import("react").JSX.Element;
 export default Microphone;

package/dist/components/SettingsMenu.d.ts

@@ -10,7 +10,10 @@ interface SettingsMenuProps {
     setShowSettings?: (value: boolean) => void;
     transcriptPosition: TranscriptPosition;
     micPosition?: MicButtonPosition;
+    showConfigButton?: boolean;
+    onOpenConfig?: () => void;
+    isConfigDialogOpen?: boolean;
     React: typeof import('react');
 }
-declare const SettingsMenu: ({ handleResetChat, hasMic, isMuted, handleToggleMute, showTranscript, handleToggleTranscript, showSettings, setShowSettings, transcriptPosition, micPosition, React }: SettingsMenuProps) => import("react").JSX.Element;
+declare const SettingsMenu: ({ handleResetChat, hasMic, isMuted, handleToggleMute, showTranscript, handleToggleTranscript, showSettings, setShowSettings, transcriptPosition, micPosition, showConfigButton, onOpenConfig, isConfigDialogOpen, React, }: SettingsMenuProps) => import("react").JSX.Element;
 export default SettingsMenu;

package/dist/components/TranscriptBox.d.ts

@@ -12,6 +12,8 @@ interface TranscriptBoxProps {
     handleTextSubmit?: () => void;
     handleTextKeyPress?: (event: React.KeyboardEvent) => void;
     textPlaceholder?: string;
+    /** Connection status message (e.g. "Initializing...", "Retrying...") */
+    connectionMessage?: string | null;
     micPosition?: MicButtonPosition;
     transcriptPosition: TranscriptPosition;
     hasMic: boolean;
@@ -22,10 +24,14 @@ interface TranscriptBoxProps {
     showSettings?: boolean;
     setShowSettings?: (value: boolean) => void;
     isDataChannelOpen?: boolean;
+    isResponseActive?: boolean;
+    showConfigButton?: boolean;
+    onOpenConfig?: () => void;
+    isConfigDialogOpen?: boolean;
     React: typeof import('react');
 }
 declare const TranscriptBox: {
-    ({ allMessages, showTranscript, handleCloseTranscript, handleToggleTranscript, showTextInput, textInput, setTextInput, handleTextSubmit, handleTextKeyPress, textPlaceholder, micPosition, transcriptPosition, hasMic, isMuted, handleToggleMute, isConversationActive, handleResetChat, showSettings, setShowSettings, isDataChannelOpen, React }: TranscriptBoxProps): import("react").JSX.Element | null;
+    ({ allMessages, showTranscript, handleCloseTranscript: _handleCloseTranscript, handleToggleTranscript, showTextInput, textInput, setTextInput, handleTextSubmit, handleTextKeyPress, textPlaceholder, connectionMessage, micPosition, transcriptPosition, hasMic, isMuted, handleToggleMute, isConversationActive: _isConversationActive, handleResetChat, showSettings, setShowSettings, isDataChannelOpen, isResponseActive, showConfigButton, onOpenConfig, isConfigDialogOpen, React, }: TranscriptBoxProps): import("react").JSX.Element | null;
     displayName: string;
 };
 export default TranscriptBox;

package/dist/components/TranscriptTextInput.d.ts

@@ -4,8 +4,11 @@ interface TranscriptTextInputProps {
     handleTextSubmit?: () => void;
     handleTextKeyPress?: (event: React.KeyboardEvent) => void;
     textPlaceholder?: string;
+    /** Connection status message (e.g. "Initializing...", "Retrying...") - shown when channel not open */
+    connectionMessage?: string | null;
     isDataChannelOpen?: boolean;
+    isResponseActive?: boolean;
     React: typeof import('react');
 }
-declare const TranscriptTextInput: ({ textInput, setTextInput, handleTextSubmit, handleTextKeyPress, textPlaceholder, isDataChannelOpen, React }: TranscriptTextInputProps) => import("react").JSX.Element;
+declare const TranscriptTextInput: ({ textInput, setTextInput, handleTextSubmit, handleTextKeyPress, textPlaceholder, connectionMessage, isDataChannelOpen, isResponseActive, React, }: TranscriptTextInputProps) => import("react").JSX.Element;
 export default TranscriptTextInput;

package/dist/components/TranscriptToggle.d.ts

@@ -3,5 +3,5 @@ interface TranscriptToggleProps {
     handleToggleTranscript?: () => void;
     React: typeof import('react');
 }
-declare const TranscriptToggle: ({ showTranscript, handleToggleTranscript, React }: TranscriptToggleProps) => import("react").JSX.Element;
+declare const TranscriptToggle: ({ showTranscript, handleToggleTranscript, React, }: TranscriptToggleProps) => import("react").JSX.Element;
 export default TranscriptToggle;

package/dist/hooks/useGuideAIAPI.d.ts

@@ -18,5 +18,6 @@ export interface UseGuideAIAPIParams {
     handleToggleInputMode: () => void;
     handleTextSubmit: (text?: string) => Promise<void>;
     visualContextWindowAPI: any;
+    setShowConfigButton: (value: boolean) => void;
 }
 export declare function useGuideAIAPI(params: UseGuideAIAPIParams): void;

package/dist/hooks/useWebRTC.d.ts

@@ -8,6 +8,11 @@ import { ConversationManager } from '../utils/conversationManager';
 import type { RecordingStatus } from '../types/GuideAI.types';
 import type { GuideAIEnvironment } from '../types/GuideAI.types';
 import type { StoredMessage } from '../utils/messageStorage';
+export type PropTools = Record<string, {
+    description: string;
+    parameters: object;
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
+}>;
 export interface UseWebRTCParams {
     hooks: {
         useRef: <T>(initialValue: T) => {
@@ -18,12 +23,9 @@ export interface UseWebRTCParams {
     organizationKey: string;
     environment: GuideAIEnvironment;
     setIsDataChannelOpen: (open: boolean) => void;
+    setIsResponseActive: (active: boolean) => void;
     setIsConnecting: (connecting: boolean) => void;
     setStatus: (status: RecordingStatus) => void;
-    handleHighlightThenClick: (out: any) => Promise<boolean>;
-    handleHoverThenClick: (out: any) => Promise<boolean>;
-    handleHover: (out: any) => Promise<boolean>;
-    handleGoToAElmLink: (linkText: string, delay?: number) => Promise<boolean>;
     handleResetChatRef: {
         current: () => Promise<void>;
     };
@@ -38,6 +40,16 @@ export interface UseWebRTCParams {
         current: ConversationManager | null;
     };
     onMessageLogged: () => void;
+    /** Optional tools from component prop: Record<functionName, { description, parameters, execute }> */
+    tools?: PropTools;
+    onSessionUpdated?: (session: any) => void;
+    onAudioOutputStarted?: () => void;
+    /** Set connection message (e.g. "Retrying...") during init retries */
+    setConnectionMessage: (msg: string | null) => void;
+    /** Called when initialize fails after all retries */
+    onInitializeError?: (error: {
+        message: string;
+    }) => void;
 }
 export declare function useWebRTC(params: UseWebRTCParams): {
     peerConnectionRef: {

package/dist/types/GuideAI.types.d.ts

@@ -22,7 +22,6 @@ export type GuideAIPosition = {
 export type MicButtonPosition = GuideAIPosition;
 export interface GuideAIProps {
     organizationKey: string;
-    workflowKey?: string;
     environment?: GuideAIEnvironment;
     React: typeof import('react');
     ReactDOM: any;
@@ -38,6 +37,16 @@ export interface GuideAIProps {
         placeholder?: string;
     };
     visualContext?: VisualContextConfig;
+    /** Custom tools: Record<functionName, { description, parameters, execute }> - always custom handler */
+    tools?: Record<string, {
+        description: string;
+        parameters: object;
+        execute: (args: Record<string, unknown>) => Promise<unknown>;
+    }>;
+    /** Called when initialize fails after all retries. Host can show toast. */
+    onInitializeError?: (error: {
+        message: string;
+    }) => void;
 }
 export type TranscriptPosition = 'right' | 'left';
 export type PopupPosition = 'above' | 'below' | 'above-left' | 'above-right' | 'above-center' | 'below-left' | 'below-right' | 'below-center';

package/dist/types/audioConfig.types.d.ts

@@ -0,0 +1,71 @@
+export interface ServerVadConfig {
+    type: 'server_vad';
+    create_response?: boolean;
+    interrupt_response?: boolean;
+    threshold?: number;
+    silence_duration_ms?: number | undefined;
+    prefix_padding_ms?: number | undefined;
+    idle_timeout_ms?: number | null;
+}
+export interface SemanticVadConfig {
+    type: 'semantic_vad';
+    create_response?: boolean;
+    interrupt_response?: boolean;
+    eagerness?: 'low' | 'medium' | 'high' | 'auto';
+}
+export type TurnDetectionConfig = ServerVadConfig | SemanticVadConfig;
+export type NoiseReductionType = 'near_field' | 'far_field';
+export interface NoiseReductionConfig {
+    type: NoiseReductionType;
+}
+export interface AudioConfigInput {
+    noise_reduction?: NoiseReductionConfig | null;
+    turn_detection?: TurnDetectionConfig | null;
+}
+export interface AudioConfigOutput {
+    speed?: number;
+    voice?: string;
+}
+export interface AudioConfig {
+    input?: AudioConfigInput;
+    output?: AudioConfigOutput;
+}
+/**
+ * Tracks which fields the user has customized (unchecked "Default").
+ * If a key is absent or true, that field uses the hardcoded default.
+ */
+export interface AudioConfigDefaults {
+    noise_reduction?: boolean;
+    vad_type?: boolean;
+    create_response?: boolean;
+    interrupt_response?: boolean;
+    threshold?: boolean;
+    silence_duration_ms?: boolean;
+    prefix_padding_ms?: boolean;
+    idle_timeout_ms?: boolean;
+    eagerness?: boolean;
+    speed?: boolean;
+    voice?: boolean;
+}
+export interface StoredAudioConfig {
+    config: AudioConfig;
+    useDefaults: AudioConfigDefaults;
+}
+export declare const VOICES: readonly ["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse", "marin", "cedar"];
+export type VoiceName = (typeof VOICES)[number];
+export declare const DEFAULT_AUDIO_CONFIG: AudioConfig;
+export declare const DEFAULT_SERVER_VAD: ServerVadConfig;
+export declare const DEFAULT_SEMANTIC_VAD: SemanticVadConfig;
+export declare const ALL_DEFAULTS_TRUE: AudioConfigDefaults;
+export declare const FIELD_INFO: Record<string, string>;
+export declare function mergeWithDefaults(stored: StoredAudioConfig | null): AudioConfig;
+/**
+ * Builds the audio payload for session.update from an AudioConfig.
+ * All types match the API shape directly -- no conversion needed.
+ */
+export declare function buildAudioSessionPayload(config: AudioConfig): Record<string, any>;
+export interface ValidationError {
+    field: string;
+    message: string;
+}
+export declare function validateAudioConfig(config: AudioConfig): ValidationError[];

package/dist/utils/api.d.ts

@@ -1,15 +1,10 @@
 import { GuideAIEnvironment } from '../types/GuideAI.types';
 import { MessageData } from './conversationManager';
 export declare function getApiHeaders(): Record<string, string>;
-export interface Workflow {
-    id: string;
+export interface PropToolDefinition {
     name: string;
-    triggers: string[];
-    organizationKey: string;
-    prompt: string;
-    archived?: boolean;
-    createdAt?: string;
-    updatedAt?: string;
+    description: string;
+    parameters: object;
 }
 export interface InitializeWebRTCPayload {
     sdp: string;
@@ -17,9 +12,25 @@ export interface InitializeWebRTCPayload {
     user?: string;
     conversationId?: string;
 }
+export interface ToolFromServer {
+    toolConfig: object;
+    functionConfig: object;
+}
 export interface InitializeWebRTCResponse {
     answerSdp: string;
     id: string;
+    tools?: ToolFromServer[];
 }
 export declare const initializeWebRTC: (endpoint: string, payload: InitializeWebRTCPayload) => Promise<InitializeWebRTCResponse>;
+/** Fire-and-forget: register prop tools (customer-scoped) and built-in tools (global) not in registry. Does not await. */
+export declare const registerTools: (endpoint: string, payload: {
+    organizationKey: string;
+    propTools?: PropToolDefinition[];
+    builtInTools?: PropToolDefinition[];
+}) => void;
+/** Built-in tool definition for server registration */
+export interface BuiltInToolDefinition {
+    toolConfig: object;
+    functionConfig: object;
+}
 export declare const logMessage: (messageData: MessageData, conversationId: string | null, organizationKey: string, user?: string, environment?: GuideAIEnvironment) => Promise<void>;

package/dist/utils/clickElement.d.ts

@@ -0,0 +1,7 @@
+import { ToolInput } from './elementInteractions';
+/**
+ * Perform a single click on an element (used by click tool and by highlightThenClick/hoverThenClick).
+ * Resolves clickable subelement, dispatches click, optionally shows ripple/emphasis.
+ */
+export declare function performClick(element: Element, rect: DOMRect, withEffect: boolean, cursor: HTMLElement | null, interactionTime?: number): Promise<void>;
+export declare const clickElement: (out: ToolInput) => Promise<boolean>;

package/dist/utils/constants.d.ts

@@ -5,7 +5,6 @@ export declare const GUIDE_AI_API_BASE_LOCAL = "http://localhost:3000/api";
 export declare const getApiBaseUrl: (environment?: "development" | "production" | "local") => string;
 export declare const GUIDE_AI_API_BASE = "https://app.getguide.ai/api";
 export declare const OPENAI_REALTIME_BASE = "https://api.openai.com/v1/realtime/calls";
-export type ElementInteractionType = "HIGHLIGHT" | "HOVERANDCLICK";
 export declare const UI_LAYOUT: {
     /** Mic/icon wrapper size - matches .guideai-icon-wrapper */
     readonly micButtonSize: 50;

package/dist/utils/dataChannel.d.ts

@@ -1,18 +1,17 @@
 import { StoredMessage } from './messageStorage';
+import { type ToolWithConfig } from './toolRegistry';
 import { ConversationManager } from './conversationManager';
+import { AudioConfig } from '../types/audioConfig.types';
 export type RecordingStatus = 'idle' | 'recording' | 'active' | 'processing' | 'playing';
 export declare const IGNORE_MESSAGE_TYPES: string[];
 export interface DataChannelCallbacks {
     setIsDataChannelOpen: (open: boolean) => void;
     setIsConnecting: (connecting: boolean) => void;
     setStatus: (status: RecordingStatus) => void;
-    handleHighlightThenClick: (out: any) => Promise<boolean>;
-    handleHoverThenClick: (out: any) => Promise<boolean>;
-    handleHover: (out: any) => Promise<boolean>;
-    handleGoToAElmLink: (linkText: string, delay?: number) => Promise<boolean>;
     onDataChannelClose: (pc: RTCPeerConnection) => void;
     onDataChannelError: (event: Event) => void;
     onDataChannelMessageError: (message: any) => void;
+    setIsResponseActive: (active: boolean) => void;
     updateStreamingMessage: (delta: string) => void;
     /** Reset streaming state when a new response starts (call on response.created) */
     resetStreamingMessage?: () => void;
@@ -24,10 +23,20 @@ export interface DataChannelCallbacks {
         current: ConversationManager | null;
     };
     updateSessionId?: (sessionId: string | null) => void;
+    onSessionUpdated?: (session: any) => void;
+    onAudioOutputStarted?: () => void;
 }
 export interface DataChannelConfig {
     audioStream: MediaStream | null;
     callbacks: DataChannelCallbacks;
+    /** Tools from server (initialize response). If undefined = old server, use built-in. If [] = new server, no tools. */
+    tools?: ToolWithConfig[];
+    /** Prop tools: Record<functionName, { description, parameters, execute }> - always custom handler */
+    propTools?: Record<string, {
+        description: string;
+        parameters: object;
+        execute: (args: Record<string, unknown>) => Promise<unknown>;
+    }>;
 }
 export declare const BUFFERED_AMOUNT_THRESHOLD = 65536;
 export declare class DataChannelManager {
@@ -36,7 +45,12 @@ export declare class DataChannelManager {
     private callbacks;
     private audioStream;
     private sendQueue;
+    private toolsConfig;
+    private serverToolsReceived;
+    private propTools?;
     constructor(config: DataChannelConfig);
+    /** Set tools from server (call after initialize, before channel opens) */
+    setTools(tools: ToolWithConfig[]): void;
     /**
      * Create a new data channel on the peer connection
      */
@@ -66,6 +80,17 @@ export declare class DataChannelManager {
      * Check if the data channel is open and ready
      */
     isOpen(): boolean;
+    /**
+     * Build an audio session payload by merging hardcoded defaults with localStorage.
+     * Converts internal types to the API format (e.g. noise_reduction string -> object).
+     */
+    private buildMergedAudioPayload;
+    /**
+     * Send a session.update with an AudioConfig payload.
+     * Converts internal types to API format via buildAudioSessionPayload.
+     * Used by the config dialog Apply and Reset buttons.
+     */
+    sendAudioSessionUpdate(config: AudioConfig): void;
     /**
      * Get the current buffered amount in bytes
      */

package/dist/utils/dataChannelHelpers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Helper functions for data channel message handling.
+ * Extracted from dataChannel.ts to keep the main module focused on orchestration.
+ */
+/** Check if message is a conversation.item.create with input_text */
+export declare function hasInputText(message: unknown): boolean;
+/** Check if message is image-only (no text) */
+export declare function isImageOnlyMessage(message: unknown): boolean;
+/** Check if payload string is an image-only message */
+export declare function isImageOnlyPayload(payload: string): boolean;
+/** Persist server-accepted audio config from session.updated to localStorage */
+export declare function persistAudioConfigFromSession(session: {
+    audio?: {
+        input?: {
+            noise_reduction?: unknown;
+            turn_detection?: unknown;
+        };
+        output?: {
+            speed?: unknown;
+            voice?: unknown;
+        };
+    };
+}): void;
+/** Build conversation context message to send after session.updated, or null if no stored messages */
+export declare function buildConversationContextMessage(organizationKey: string): {
+    type: string;
+    item: object;
+} | null;

package/dist/utils/elementInteractions.d.ts

@@ -1,11 +1,11 @@
-import { ElementInteractionType } from './constants';
 export interface ToolInput {
     arguments: string;
     name?: string;
 }
-export declare const HOVER_EFFECT_KEEP_ALIVE_TIME = 3000;
+export declare const HOVER_EFFECT_KEEP_ALIVE_TIME = 1500;
+export declare const getLastNavigateTimestamp: () => number | null;
+export declare const waitForElement: (selector: string, timeout?: number, interval?: number) => Promise<Element | null>;
 export declare const createHoverEffect: (element: Element, initialRect: DOMRect, cursorElement?: HTMLElement | null, duration?: number) => Promise<void>;
-export declare const clickElement: (element: Element, rect: DOMRect, withEffects?: boolean, cursorElement?: HTMLElement | null) => Promise<void>;
 export declare const parseCustomSelector: (selector: string) => {
     type: "text" | "css" | "xpath";
     cssSelector?: string;
@@ -14,10 +14,79 @@ export declare const parseCustomSelector: (selector: string) => {
 };
 export declare const findElementBySelectorStrict: (selector: string) => Element | null;
 export declare const findElementBySelector: (selector: string) => Element | null;
-export declare const interactWithElement: (element: Element, cursorElement: HTMLElement | null, state: ElementInteractionType, hoverTime?: number) => Promise<HTMLElement | null>;
-export declare const processSelectorsInteraction: (selectors: string | string[], isInteracting: boolean, setIsInteracting: (interacting: boolean) => void, onEachElement: (element: Element, cursor: HTMLElement | null, index: number) => Promise<HTMLElement | null>, onComplete?: (lastElement: Element | null, cursor: HTMLElement | null) => Promise<void>) => Promise<boolean>;
+export declare function getEffectiveZIndex(element: Element | null): number;
+export declare const moveCursorToElement: (element: Element, cursorElement: HTMLElement | null) => Promise<HTMLElement | null>;
+type InteractionJob = () => Promise<void>;
+export declare const enqueueInteractionJob: (job: InteractionJob) => void;
 export declare const parseArgs: (argsToUse: string) => Promise<any>;
-export declare const Highlight_Click_Tool: {
+export declare const Highlight_Tool: {
+    type: string;
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            selector: {
+                type: string;
+                description: string;
+            };
+            interactionTime: {
+                type: string;
+                description: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const Click_Tool: {
+    type: string;
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            selector: {
+                type: string;
+                description: string;
+            };
+            withEffect: {
+                type: string;
+                description: string;
+            };
+            interactionTime: {
+                type: string;
+                description: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const Hover_Tool: {
+    type: string;
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            selector: {
+                type: string;
+                description: string;
+            };
+            interactionTime: {
+                type: string;
+                description: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const Highlight_Then_Click_Tool: {
     type: string;
     name: string;
     description: string;
@@ -42,7 +111,7 @@ export declare const Highlight_Click_Tool: {
         required: string[];
     };
 };
-export declare const Hover_Click_Tool: {
+export declare const Hover_Then_Click_Tool: {
     type: string;
     name: string;
     description: string;
@@ -73,28 +142,18 @@ export declare const Hover_Click_Tool: {
         required: string[];
     };
 };
-export declare const Hover_Tool: {
+export declare const Navigate_To_Tool: {
     type: string;
     name: string;
     description: string;
     parameters: {
         type: string;
         properties: {
-            selector: {
-                oneOf: ({
-                    type: string;
-                    description: string;
-                    items?: undefined;
-                } | {
-                    type: string;
-                    items: {
-                        type: string;
-                    };
-                    description: string;
-                })[];
+            url: {
+                type: string;
                 description: string;
             };
-            hoverTime: {
+            delay: {
                 type: string;
                 description: string;
                 minimum: number;
@@ -125,3 +184,33 @@ export declare const Go_To_A_Elm_Link_Tool: {
         required: string[];
     };
 };
+export declare const Fill_Field_Tool: {
+    type: string;
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            fieldName: {
+                type: string;
+                description: string;
+            };
+            selector: {
+                type: string;
+                description: string;
+            };
+            value: {
+                type: string;
+                description: string;
+            };
+            delay: {
+                type: string;
+                description: string;
+                minimum: number;
+                maximum: number;
+            };
+        };
+        required: string[];
+    };
+};
+export {};

package/dist/utils/fillField.d.ts

@@ -0,0 +1,2 @@
+import { ToolInput } from './elementInteractions';
+export declare const fillField: (out: ToolInput) => Promise<boolean>;

package/dist/utils/goToAElmLink.d.ts

@@ -1 +1,6 @@
-export declare const goToAElmLink: (linkText: string, delay?: number) => Promise<boolean>;
+import { ToolInput } from './elementInteractions';
+/**
+ * Tool entry for goToAElmLink. Parses linkText and delay from args and enqueues the navigation job.
+ * @deprecated Prefer navigateTo. This tool is for legacy Momentum-style markup (span text + data-momentum-client-link).
+ */
+export declare const goToAElmLink: (out: ToolInput) => Promise<boolean>;

package/dist/utils/highlight.d.ts

@@ -0,0 +1,2 @@
+import { ToolInput } from './elementInteractions';
+export declare const highlight: (out: ToolInput) => Promise<boolean>;

package/dist/utils/highlightThenClick.d.ts

@@ -1,2 +1,6 @@
-import { ToolInput } from "./elementInteractions";
-export declare const highlightThenClick: (out: ToolInput, isHighlighting: boolean, setIsHighlighting: (highlighting: boolean) => void) => Promise<boolean>;
+import { ToolInput } from './elementInteractions';
+/**
+ * Highlight (move cursor to) each element then click it. Supports a single selector or array of selectors.
+ * Same behavior as legacy: cursor moves to each element in sequence and clicks with visual effect.
+ */
+export declare const highlightThenClick: (out: ToolInput) => Promise<boolean>;

package/dist/utils/hover.d.ts

@@ -1,2 +1,2 @@
 import { ToolInput } from './elementInteractions';
-export declare const hover: (out: ToolInput, isHovering: boolean, setIsHovering: (hovering: boolean) => void) => Promise<boolean>;
+export declare const hover: (out: ToolInput) => Promise<boolean>;

package/dist/utils/hoverThenClick.d.ts

@@ -1,2 +1,6 @@
 import { ToolInput } from './elementInteractions';
-export declare const hoverThenClick: (out: ToolInput, isHovering: boolean, setIsHovering: (hovering: boolean) => void) => Promise<boolean>;
+/**
+ * Hover over each element (with hover effect), then click the last element. Supports single selector or array.
+ * Same behavior as legacy: cursor moves to each, hover effect runs, then last element is clicked (no click effect).
+ */
+export declare const hoverThenClick: (out: ToolInput) => Promise<boolean>;