guideai-app 0.4.3-9 → 0.5.0

package/dist/components/AnimatedSettingsItem.d.ts

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

package/dist/components/Microphone.d.ts

@@ -3,7 +3,6 @@ interface MicrophoneProps {
     componentRef: React.RefObject<HTMLDivElement>;
     baseStyles: React.CSSProperties;
     hasInteracted: boolean;
-    ephemeralToken: string | null;
     popupPosition: PopupPosition;
     showOnboarding: boolean;
     handleOnboardingComplete: () => void;
@@ -16,5 +15,5 @@ interface MicrophoneProps {
     isMuted: boolean;
     React: typeof import('react');
 }
-declare const Microphone: ({ componentRef, baseStyles, hasInteracted, ephemeralToken, 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, status, handleToggleConversation, showTranscript, hasMic, isMuted, React }: MicrophoneProps) => import("react").JSX.Element;
 export default Microphone;

package/dist/components/MuteButton.d.ts

@@ -1,15 +1,11 @@
-import { TranscriptPosition, MicButtonPosition } from '../types/GuideAI.types';
 interface MuteButtonProps {
-    transcriptPosition: TranscriptPosition;
-    micPosition?: MicButtonPosition;
     hasMic: boolean;
     isMuted?: boolean;
     handleToggleMute?: () => void;
-    isConversationActive?: boolean;
     React: typeof import('react');
 }
 declare const MuteButton: {
-    ({ transcriptPosition, micPosition, hasMic, isMuted, handleToggleMute, isConversationActive, React }: MuteButtonProps): import("react").JSX.Element | null;
+    ({ hasMic, isMuted, handleToggleMute, React }: MuteButtonProps): import("react").JSX.Element;
     displayName: string;
 };
 export default MuteButton;

package/dist/components/ResetButton.d.ts

@@ -1,13 +1,9 @@
-import { TranscriptPosition, MicButtonPosition } from '../types/GuideAI.types';
 interface ResetButtonProps {
-    transcriptPosition: TranscriptPosition;
-    micPosition?: MicButtonPosition;
-    isConversationActive?: boolean;
-    handleResetChatHistory?: () => void;
+    handleResetChat?: () => void;
     React: typeof import('react');
 }
 declare const ResetButton: {
-    ({ transcriptPosition, micPosition, isConversationActive, handleResetChatHistory, React }: ResetButtonProps): import("react").JSX.Element | null;
+    ({ handleResetChat, React }: ResetButtonProps): import("react").JSX.Element;
     displayName: string;
 };
 export default ResetButton;

package/dist/components/SettingsMenu.d.ts

@@ -0,0 +1,16 @@
+import { TranscriptPosition, MicButtonPosition } from '../types/GuideAI.types';
+interface SettingsMenuProps {
+    handleResetChat?: () => void;
+    hasMic: boolean;
+    isMuted: boolean;
+    handleToggleMute: () => void;
+    showTranscript: boolean;
+    handleToggleTranscript: () => void;
+    showSettings: boolean;
+    setShowSettings?: (value: boolean) => void;
+    transcriptPosition: TranscriptPosition;
+    micPosition?: MicButtonPosition;
+    React: typeof import('react');
+}
+declare const SettingsMenu: ({ handleResetChat, hasMic, isMuted, handleToggleMute, showTranscript, handleToggleTranscript, showSettings, setShowSettings, transcriptPosition, micPosition, React }: SettingsMenuProps) => import("react").JSX.Element;
+export default SettingsMenu;

package/dist/components/SettingsToggle.d.ts

@@ -0,0 +1,7 @@
+interface SettingsToggleProps {
+    showSettings: boolean;
+    setShowSettings?: (value: boolean) => void;
+    React: typeof import('react');
+}
+declare const SettingsToggle: ({ showSettings, setShowSettings, React }: SettingsToggleProps) => import("react").JSX.Element;
+export default SettingsToggle;

package/dist/components/TranscriptBox.d.ts

@@ -18,12 +18,14 @@ interface TranscriptBoxProps {
     isMuted?: boolean;
     handleToggleMute?: () => void;
     isConversationActive?: boolean;
-    handleResetChatHistory?: () => void;
+    handleResetChat?: () => void;
+    showSettings?: boolean;
+    setShowSettings?: (value: boolean) => void;
     isDataChannelOpen?: boolean;
     React: typeof import('react');
 }
 declare const TranscriptBox: {
-    ({ allMessages, showTranscript, handleCloseTranscript, showToggleButton, handleToggleTranscript, showTextInput, textInput, setTextInput, handleTextSubmit, handleTextKeyPress, textPlaceholder, micPosition, transcriptPosition, hasMic, isMuted, handleToggleMute, isConversationActive, handleResetChatHistory, isDataChannelOpen, React }: TranscriptBoxProps): import("react").JSX.Element | null;
+    ({ 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;
     displayName: string;
 };
 export default TranscriptBox;

package/dist/components/TranscriptToggle.d.ts

@@ -1,10 +1,7 @@
-import { TranscriptPosition, MicButtonPosition } from '../types/GuideAI.types';
 interface TranscriptToggleProps {
-    transcriptPosition: TranscriptPosition;
-    micPosition?: MicButtonPosition;
     showTranscript: boolean;
     handleToggleTranscript?: () => void;
     React: typeof import('react');
 }
-declare const TranscriptToggle: ({ transcriptPosition, micPosition, 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/index.d.ts

@@ -0,0 +1,3 @@
+export { useGuideAIAPI } from './useGuideAIAPI';
+export { useTranscriptState } from './useTranscriptState';
+export { useWebRTC } from './useWebRTC';

package/dist/hooks/useGuideAIAPI.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Exposes GuideAI methods globally on window for external access.
+ */
+import type { UseEffectHook } from '../types/GuideAI.types';
+export interface UseGuideAIAPIParams {
+    useEffect: UseEffectHook;
+    organizationKey: string;
+    setShowTranscript: (value: React.SetStateAction<boolean>) => void;
+    showTranscript: boolean;
+    setInputMode: (mode: 'voice' | 'text') => void;
+    setShowTextInput: (value: React.SetStateAction<boolean>) => void;
+    inputMode: 'voice' | 'text';
+    setTextInput: (value: React.SetStateAction<string>) => void;
+    inputOptions?: {
+        enableTextInput?: boolean;
+    };
+    isConversationActive: boolean;
+    handleToggleInputMode: () => void;
+    handleTextSubmit: (text?: string) => Promise<void>;
+    visualContextWindowAPI: any;
+}
+export declare function useGuideAIAPI(params: UseGuideAIAPIParams): void;

package/dist/hooks/useTranscriptState.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Manages transcript/message state: sync from storage, streaming updates.
+ */
+import type { StoredMessage } from '../utils/messageStorage';
+import type { RecordingStatus } from '../types/GuideAI.types';
+export interface UseTranscriptStateParams {
+    hooks: {
+        useRef: <T>(initialValue: T) => {
+            current: T;
+        };
+        useCallback: <T extends (...args: any[]) => any>(callback: T, deps: any[]) => T;
+    };
+    organizationKey: string;
+    setAllMessages: React.Dispatch<React.SetStateAction<StoredMessage[]>>;
+    setStatus: (status: RecordingStatus) => void;
+}
+export declare function useTranscriptState(params: UseTranscriptStateParams): {
+    syncMessagesFromStorage: () => StoredMessage[];
+    cleanupStreamingMessageState: () => void;
+    updateStreamingMessage: (text: string) => void;
+};

package/dist/hooks/useWebRTC.d.ts

@@ -0,0 +1,63 @@
+/**
+ * WebRTC connection management hook.
+ * Handles peer connection, data channel, audio element refs, cleanup, and initialization.
+ */
+import { WebRTCConnection } from '../utils/webrtcConnection';
+import { DataChannelManager } from '../utils/dataChannel';
+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 interface UseWebRTCParams {
+    hooks: {
+        useRef: <T>(initialValue: T) => {
+            current: T;
+        };
+        useCallback: <T extends (...args: any[]) => any>(callback: T, deps: any[]) => T;
+    };
+    organizationKey: string;
+    environment: GuideAIEnvironment;
+    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>;
+    handleResetChatRef: {
+        current: () => Promise<void>;
+    };
+    endConversationSessionRef: {
+        current: () => void;
+    };
+    updateStreamingMessage: (text: string) => void;
+    cleanupStreamingMessageState: () => void;
+    allMessages: StoredMessage[];
+    status: RecordingStatus;
+    conversationManagerRef: {
+        current: ConversationManager | null;
+    };
+    onMessageLogged: () => void;
+}
+export declare function useWebRTC(params: UseWebRTCParams): {
+    peerConnectionRef: {
+        current: RTCPeerConnection | null;
+    };
+    dataChannelManagerRef: {
+        current: DataChannelManager | null;
+    };
+    mediaStreamRef: {
+        current: MediaStream | null;
+    };
+    audioElementRef: {
+        current: HTMLAudioElement | null;
+    };
+    webrtcConnectionRef: {
+        current: WebRTCConnection | null;
+    };
+    conversationIdRef: {
+        current: string | null;
+    };
+    cleanupWebRTC: () => void;
+    initializeWebRTC: (audioStream: MediaStream | null) => Promise<boolean>;
+};

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export type { GuideAIProps, GuideAIEnvironment } from './types/GuideAI.types';
 export * from './visualContext';
 export * from './visualContext/types';
 export { getSessionId, clearSessionId, peekSessionId } from './utils/session';
+export { STORAGE_KEYS } from './utils/localStorageHelper';

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

@@ -1,5 +1,5 @@
 import { VisualContextConfig } from '../visualContext/types';
-export type RecordingStatus = 'idle' | 'recording' | 'processing' | 'playing';
+export type RecordingStatus = 'idle' | 'recording' | 'active' | 'processing' | 'playing';
 export type UseStateHook = <T>(initialState: T | (() => T)) => [T, (value: T | ((prev: T) => T)) => void];
 export type UseEffectHook = (effect: () => void | (() => void), deps?: any[]) => void;
 export type UseRefHook = <T>(initialValue: T) => {
@@ -29,7 +29,6 @@ export interface GuideAIProps {
     position?: GuideAIPosition;
     transcript?: {
         enabled?: boolean;
-        showToggleButton?: boolean;
         position?: TranscriptPosition;
     };
     input?: {

package/dist/utils/api.d.ts

@@ -1,21 +1,25 @@
 import { GuideAIEnvironment } from '../types/GuideAI.types';
-interface Workflow {
+import { MessageData } from './conversationManager';
+export declare function getApiHeaders(): Record<string, string>;
+export interface Workflow {
     id: string;
     name: string;
     triggers: string[];
     organizationKey: string;
     prompt: string;
-    archived: boolean;
-    createdAt: string;
-    updatedAt: string;
+    archived?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
 }
-interface ConversationData {
-    tokenExpiresAt: number;
+export interface InitializeWebRTCPayload {
+    sdp: string;
+    organizationKey: string;
+    user?: string;
+    conversationId?: string;
+}
+export interface InitializeWebRTCResponse {
+    answerSdp: string;
     id: string;
-    ephemeralToken: string;
-    prompt: string;
-    workflows: Workflow[];
 }
-export declare const createNewConversation: (organizationKey: string, workflowKey?: string, environment?: GuideAIEnvironment) => Promise<ConversationData | null>;
-export type { Workflow };
-export declare const logMessage: (content: string, sender: "GUIDEAI" | "HUMAN", conversationId: string | null, organizationKey: string, environment?: GuideAIEnvironment) => Promise<void>;
+export declare const initializeWebRTC: (endpoint: string, payload: InitializeWebRTCPayload) => Promise<InitializeWebRTCResponse>;
+export declare const logMessage: (messageData: MessageData, conversationId: string | null, organizationKey: string, user?: string, environment?: GuideAIEnvironment) => Promise<void>;

package/dist/utils/constants.d.ts

@@ -1,8 +1,22 @@
 export declare const DEFAULT_PROMPT = "you are Guide AI.\n      Your role is to answer any question directly and succinctly that a user has. NEVER DIRECTLY MENTION THE SCREENSHOT, but use its information as much as possible to target your responses.\n      If nothing is asked, then your goal is to generally assist them.\n      IMPORTANT: NEVER answer in more than 10 words. Always be concise and limit answers to 1 sentence maximum. Be simple and as short as possible.\n      Your job is to help them get it done through asking more and more targeted specific questions.";
-export declare const GUIDE_AI_API_BASE_PROD = "https://www.getguide.ai/api";
+export declare const GUIDE_AI_API_BASE_PROD = "https://app.getguide.ai/api";
 export declare const GUIDE_AI_API_BASE_DEV = "https://dev.getguide.ai/api";
 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://www.getguide.ai/api";
-export declare const OPENAI_REALTIME_BASE = "https://api.openai.com/v1/realtime";
+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;
+    /** Space between mic top and lowest toggle bottom */
+    readonly toggleAboveMicGap: 12;
+    /** Gap between stacked buttons (e.g. transcript above settings) */
+    readonly stackedButtonGap: 8;
+    /** Horizontal offset from edge when using right/left positioning */
+    readonly horizontalEdgeOffset: 6;
+    /** Default bottom when micPosition is not provided */
+    readonly defaultBottom: 20;
+    /** Default horizontal offset when position is not provided */
+    readonly defaultHorizontalOffset: 40;
+};

package/dist/utils/conversationManager.d.ts

@@ -0,0 +1,89 @@
+import { GuideAIEnvironment } from '../types/GuideAI.types';
+/**
+ * Message type options
+ */
+export type MessageType = 'log' | 'voice' | 'text' | 'action' | 'error' | 'screenshot';
+/**
+ * Sender type options
+ */
+export type MessageSender = 'GUIDEAI' | 'HUMAN' | 'SYSTEM';
+/**
+ * Message data structure for API
+ */
+export interface MessageData {
+    content: string;
+    sender: MessageSender;
+    type: MessageType;
+    url?: string;
+    session?: string;
+    logdata?: any;
+}
+/**
+ * ConversationManager class
+ * Centralized message logging with validation and automatic field population
+ */
+export declare class ConversationManager {
+    private organizationKey;
+    private conversationId;
+    private environment?;
+    private allMessages;
+    private onMessageLogged?;
+    constructor(organizationKey: string, conversationId: string | null, environment?: GuideAIEnvironment, onMessageLogged?: () => void);
+    /**
+     * Update conversation ID (called when conversation is created/updated)
+     */
+    setConversationId(conversationId: string | null): void;
+    /**
+     * Update session ID in localStorage
+     */
+    updateSessionId(sessionId: string | null): void;
+    /**
+     * Refresh messages from storage
+     */
+    refreshMessages(): void;
+    /**
+     * Primary utility function for logging messages
+     * Handles validation, duplicate checking, and field population
+     */
+    private logMessage;
+    /**
+     * Private wrapper for logMessage - defaults type to voice
+     */
+    private logVoiceMessage;
+    /**
+     * Public wrapper - log user voice message
+     */
+    logUserVoiceMessage(content: string): Promise<void>;
+    /**
+     * Public wrapper - log GuideAI voice message
+     */
+    logGuideAIMessage(content: string): Promise<void>;
+    /**
+     * Public wrapper - log data message (type defaults to 'log')
+     */
+    logDataMessage(content: string, data?: any, type?: any): void;
+    /**
+     * Private wrapper for logMessage - defaults type to text
+     */
+    private logTextMessage;
+    /**
+     * Public wrapper - log user text message
+     */
+    logUserTextMessage(content: string): Promise<void>;
+    /**
+     * Public wrapper - log action message
+     */
+    logActionMessage(content: string, data?: any): void;
+    /**
+     * Public wrapper - log debug message
+     */
+    logDebugMessage(content: string, data?: any): void;
+    /**
+     * Public wrapper - log error message
+     */
+    logErrorMessage(content: string, data?: any): void;
+    /**
+     * Public wrapper - log visual context message
+     */
+    logVisualContextMessage(content: string, data?: any): void;
+}

package/dist/utils/dataChannel.d.ts

@@ -1,12 +1,11 @@
-import { Workflow } from './api';
 import { StoredMessage } from './messageStorage';
-export type RecordingStatus = 'idle' | 'recording' | 'processing' | 'playing';
+import { ConversationManager } from './conversationManager';
+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;
-    handleLogMessage: (content: string, sender: 'GUIDEAI' | 'HUMAN') => Promise<void>;
     handleHighlightThenClick: (out: any) => Promise<boolean>;
     handleHoverThenClick: (out: any) => Promise<boolean>;
     handleHover: (out: any) => Promise<boolean>;
@@ -14,39 +13,29 @@ export interface DataChannelCallbacks {
     onDataChannelClose: (pc: RTCPeerConnection) => void;
     onDataChannelError: (event: Event) => void;
     onDataChannelMessageError: (message: any) => void;
+    updateStreamingMessage: (delta: string) => void;
+    /** Reset streaming state when a new response starts (call on response.created) */
+    resetStreamingMessage?: () => void;
     allMessages: StoredMessage[];
     status: RecordingStatus;
-    hasMic: boolean;
     organizationKey: string;
-    prompt: string | null;
-    workflows: Workflow[];
-    hasCreatedConversationRef: {
-        current: boolean;
-    };
-    errorHandlingTimeoutRefs: {
-        current: Set<NodeJS.Timeout>;
-    };
-    updateStreamingMessage: (delta: string) => void;
-    finalizeStreamingMessage: (finalText?: string) => void;
-    streamingMessageRef: {
-        current: string;
-    };
-    isStreamingRef: {
-        current: boolean;
-    };
-    streamingMessageIdRef: {
-        current: number | null;
+    /** Ref to ConversationManager - use .current when logging (set in onSessionData before data channel opens) */
+    conversationManagerRef: {
+        current: ConversationManager | null;
     };
+    updateSessionId?: (sessionId: string | null) => void;
 }
 export interface DataChannelConfig {
     audioStream: MediaStream | null;
     callbacks: DataChannelCallbacks;
 }
+export declare const BUFFERED_AMOUNT_THRESHOLD = 65536;
 export declare class DataChannelManager {
     private dataChannel;
     private peerConnection;
     private callbacks;
     private audioStream;
+    private sendQueue;
     constructor(config: DataChannelConfig);
     /**
      * Create a new data channel on the peer connection
@@ -65,13 +54,26 @@ export declare class DataChannelManager {
      */
     private handleMessage;
     /**
-     * Send a message through the data channel
+     * Flush queued messages when buffer has drained
+     */
+    private flushSendQueue;
+    /**
+     * Send a message through the data channel.
+     * Queues the message if bufferedAmount exceeds threshold; it will be sent when buffer drains.
      */
     sendMessage(message: any): void;
     /**
      * Check if the data channel is open and ready
      */
     isOpen(): boolean;
+    /**
+     * Get the current buffered amount in bytes
+     */
+    getBufferedAmount(): number;
+    /**
+     * Check if the send buffer is full (above threshold)
+     */
+    isBufferFull(): boolean;
     /**
      * Get the current data channel
      */
@@ -80,8 +82,4 @@ export declare class DataChannelManager {
      * Close and cleanup the data channel
      */
     close(): void;
-    /**
-     * Cleanup all resources
-     */
-    cleanup(): void;
 }

package/dist/utils/elementInteractions.d.ts

@@ -5,7 +5,7 @@ export interface ToolInput {
 }
 export declare const HOVER_EFFECT_KEEP_ALIVE_TIME = 3000;
 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) => 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;

package/dist/utils/isChromeExtension.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detects if the code is running inside a Chrome extension content script.
+ * Used for audio setup and other extension-specific behavior.
+ */
+export declare function isChromeExtension(): boolean;

package/dist/utils/localStorageHelper.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Centralized localStorage helper
+ * Tracks all localStorage keys used in the application
+ */
+declare const STORAGE_KEYS: {
+    readonly USER_UUID: "guideAI_userUUID";
+    readonly SESSION_ID: "guideAI_sessionId";
+    readonly CONVERSATION: "guideAI_conversation";
+    readonly HAS_INTERACTED: "guideAI_hasInteracted";
+    readonly IS_MUTED: "guideAI_isMuted";
+    readonly LOGGER_ENABLED: "guideAI_loggerEnabled";
+};
+/**
+ * Check if localStorage is available
+ */
+export declare const isLocalStorageAvailable: () => boolean;
+/**
+ * Get or create user UUID
+ * Creates a new UUID if one doesn't exist
+ */
+export declare const getUserUUID: () => string;
+/**
+ * Get session ID (active OpenAI session)
+ */
+export declare const getSessionId: () => string | null;
+/**
+ * Set session ID
+ */
+export declare const setSessionId: (sessionId: string | null) => void;
+/**
+ * Get has interacted flag
+ */
+export declare const getHasInteracted: () => boolean;
+/**
+ * Set has interacted flag
+ */
+export declare const setHasInteracted: (value: boolean) => void;
+/**
+ * Get is muted flag
+ */
+export declare const getIsMuted: () => boolean;
+/**
+ * Set is muted flag
+ */
+export declare const setIsMuted: (value: boolean) => void;
+/**
+ * Get logger enabled flag (used by Logger to persist enable state)
+ */
+export declare const getLoggerEnabled: () => boolean;
+/**
+ * Set logger enabled flag
+ */
+export declare const setLoggerEnabled: (value: boolean) => void;
+/**
+ * Export storage keys for reference (read-only)
+ */
+export { STORAGE_KEYS };

package/dist/utils/logger.d.ts

@@ -1,4 +1,4 @@
-type Component = 'GuideAI' | 'API' | 'TranscriptBox' | 'Onboarding' | 'VisualContext' | 'MessageStorage' | 'DataChannel';
+type Component = 'GuideAI' | 'API' | 'TranscriptBox' | 'Onboarding' | 'VisualContext' | 'MessageStorage' | 'DataChannel' | 'ConversationManager' | 'LocalStorageHelper' | 'WebRTCConnection';
 declare class Logger {
     private static formatMessage;
     private static checkLoggingEnabled;
@@ -9,15 +9,15 @@ declare class Logger {
      */
     static init(): void;
     /**
-     * Enable logging from console
-     * Usage: GuideAILogger.enable()
+     * Enable logging from console, or for a specific component.
+     * Usage: GuideAILogger.enable() or GuideAILogger.enable('API')
      */
-    static enable(): void;
+    static enable(component?: Component): void;
     /**
-     * Disable logging from console
-     * Usage: GuideAILogger.disable()
+     * Disable logging from console, or for a specific component.
+     * Usage: GuideAILogger.disable() or GuideAILogger.disable('API')
      */
-    static disable(): void;
+    static disable(component?: Component): void;
     /**
      * Enable or disable logging for a specific component
      * Usage: GuideAILogger.setComponentEnabled('API', true)

package/dist/utils/messageStorage.d.ts

@@ -1,6 +1,6 @@
 export interface StoredMessage {
     content: string;
-    sender: 'GUIDEAI' | 'HUMAN';
+    sender: 'GUIDEAI' | 'HUMAN' | 'SYSTEM';
     timestamp: number;
 }
 export interface StoredConversation {
@@ -11,15 +11,13 @@ export interface StoredConversation {
     organizationKey: string;
     keyExpiresAt?: number;
     sessionExpiresAt?: number;
+    user?: string;
 }
 export declare const CONVERSATION_STORAGE_KEY = "guideAI_conversation";
 export declare const CONVERSATION_EXPIRY_MINUTES = 30;
 export declare const MAX_STORED_MESSAGES = 100;
 export declare const isLocalStorageAvailable: () => boolean;
-export declare const initializeConversationStorage: (organizationKey: string, conversationId: string, conversationKey: string, keyExpiresAt: number) => void;
-export declare const getConversationKey: (organizationKey: string) => string | null | undefined;
-export declare const resetConversationKey: (organizationKey: string) => void;
-export declare const isKeyExpired: (organizationKey: string) => boolean;
+export declare const initializeConversationStorage: (organizationKey: string, conversationId: string) => void;
 export declare const isSessionExpired: (organizationKey: string) => boolean;
 export declare const isConversationExpired: (organizationKey: string) => boolean;
 export declare const updateSessionExpiresAt: (organizationKey: string, sessionExpiresAt: number) => void;