@aomi-labs/widget-lib 0.2.0

package/dist/index.js

@@ -0,0 +1,3289 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var eventemitter3 = {exports: {}};
+
+(function (module) {
+
+	var has = Object.prototype.hasOwnProperty
+	  , prefix = '~';
+
+	/**
+	 * Constructor to create a storage for our `EE` objects.
+	 * An `Events` instance is a plain object whose properties are event names.
+	 *
+	 * @constructor
+	 * @private
+	 */
+	function Events() {}
+
+	//
+	// We try to not inherit from `Object.prototype`. In some engines creating an
+	// instance in this way is faster than calling `Object.create(null)` directly.
+	// If `Object.create(null)` is not supported we prefix the event names with a
+	// character to make sure that the built-in object properties are not
+	// overridden or used as an attack vector.
+	//
+	if (Object.create) {
+	  Events.prototype = Object.create(null);
+
+	  //
+	  // This hack is needed because the `__proto__` property is still inherited in
+	  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+	  //
+	  if (!new Events().__proto__) prefix = false;
+	}
+
+	/**
+	 * Representation of a single event listener.
+	 *
+	 * @param {Function} fn The listener function.
+	 * @param {*} context The context to invoke the listener with.
+	 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+	 * @constructor
+	 * @private
+	 */
+	function EE(fn, context, once) {
+	  this.fn = fn;
+	  this.context = context;
+	  this.once = once || false;
+	}
+
+	/**
+	 * Add a listener for a given event.
+	 *
+	 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	 * @param {(String|Symbol)} event The event name.
+	 * @param {Function} fn The listener function.
+	 * @param {*} context The context to invoke the listener with.
+	 * @param {Boolean} once Specify if the listener is a one-time listener.
+	 * @returns {EventEmitter}
+	 * @private
+	 */
+	function addListener(emitter, event, fn, context, once) {
+	  if (typeof fn !== 'function') {
+	    throw new TypeError('The listener must be a function');
+	  }
+
+	  var listener = new EE(fn, context || emitter, once)
+	    , evt = prefix ? prefix + event : event;
+
+	  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+	  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+	  else emitter._events[evt] = [emitter._events[evt], listener];
+
+	  return emitter;
+	}
+
+	/**
+	 * Clear event by name.
+	 *
+	 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+	 * @param {(String|Symbol)} evt The Event name.
+	 * @private
+	 */
+	function clearEvent(emitter, evt) {
+	  if (--emitter._eventsCount === 0) emitter._events = new Events();
+	  else delete emitter._events[evt];
+	}
+
+	/**
+	 * Minimal `EventEmitter` interface that is molded against the Node.js
+	 * `EventEmitter` interface.
+	 *
+	 * @constructor
+	 * @public
+	 */
+	function EventEmitter() {
+	  this._events = new Events();
+	  this._eventsCount = 0;
+	}
+
+	/**
+	 * Return an array listing the events for which the emitter has registered
+	 * listeners.
+	 *
+	 * @returns {Array}
+	 * @public
+	 */
+	EventEmitter.prototype.eventNames = function eventNames() {
+	  var names = []
+	    , events
+	    , name;
+
+	  if (this._eventsCount === 0) return names;
+
+	  for (name in (events = this._events)) {
+	    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+	  }
+
+	  if (Object.getOwnPropertySymbols) {
+	    return names.concat(Object.getOwnPropertySymbols(events));
+	  }
+
+	  return names;
+	};
+
+	/**
+	 * Return the listeners registered for a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @returns {Array} The registered listeners.
+	 * @public
+	 */
+	EventEmitter.prototype.listeners = function listeners(event) {
+	  var evt = prefix ? prefix + event : event
+	    , handlers = this._events[evt];
+
+	  if (!handlers) return [];
+	  if (handlers.fn) return [handlers.fn];
+
+	  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+	    ee[i] = handlers[i].fn;
+	  }
+
+	  return ee;
+	};
+
+	/**
+	 * Return the number of listeners listening to a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @returns {Number} The number of listeners.
+	 * @public
+	 */
+	EventEmitter.prototype.listenerCount = function listenerCount(event) {
+	  var evt = prefix ? prefix + event : event
+	    , listeners = this._events[evt];
+
+	  if (!listeners) return 0;
+	  if (listeners.fn) return 1;
+	  return listeners.length;
+	};
+
+	/**
+	 * Calls each of the listeners registered for a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @returns {Boolean} `true` if the event had listeners, else `false`.
+	 * @public
+	 */
+	EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+	  var evt = prefix ? prefix + event : event;
+
+	  if (!this._events[evt]) return false;
+
+	  var listeners = this._events[evt]
+	    , len = arguments.length
+	    , args
+	    , i;
+
+	  if (listeners.fn) {
+	    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+	    switch (len) {
+	      case 1: return listeners.fn.call(listeners.context), true;
+	      case 2: return listeners.fn.call(listeners.context, a1), true;
+	      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+	      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+	      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+	      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+	    }
+
+	    for (i = 1, args = new Array(len -1); i < len; i++) {
+	      args[i - 1] = arguments[i];
+	    }
+
+	    listeners.fn.apply(listeners.context, args);
+	  } else {
+	    var length = listeners.length
+	      , j;
+
+	    for (i = 0; i < length; i++) {
+	      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+	      switch (len) {
+	        case 1: listeners[i].fn.call(listeners[i].context); break;
+	        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+	        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+	        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+	        default:
+	          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+	            args[j - 1] = arguments[j];
+	          }
+
+	          listeners[i].fn.apply(listeners[i].context, args);
+	      }
+	    }
+	  }
+
+	  return true;
+	};
+
+	/**
+	 * Add a listener for a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @param {Function} fn The listener function.
+	 * @param {*} [context=this] The context to invoke the listener with.
+	 * @returns {EventEmitter} `this`.
+	 * @public
+	 */
+	EventEmitter.prototype.on = function on(event, fn, context) {
+	  return addListener(this, event, fn, context, false);
+	};
+
+	/**
+	 * Add a one-time listener for a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @param {Function} fn The listener function.
+	 * @param {*} [context=this] The context to invoke the listener with.
+	 * @returns {EventEmitter} `this`.
+	 * @public
+	 */
+	EventEmitter.prototype.once = function once(event, fn, context) {
+	  return addListener(this, event, fn, context, true);
+	};
+
+	/**
+	 * Remove the listeners of a given event.
+	 *
+	 * @param {(String|Symbol)} event The event name.
+	 * @param {Function} fn Only remove the listeners that match this function.
+	 * @param {*} context Only remove the listeners that have this context.
+	 * @param {Boolean} once Only remove one-time listeners.
+	 * @returns {EventEmitter} `this`.
+	 * @public
+	 */
+	EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+	  var evt = prefix ? prefix + event : event;
+
+	  if (!this._events[evt]) return this;
+	  if (!fn) {
+	    clearEvent(this, evt);
+	    return this;
+	  }
+
+	  var listeners = this._events[evt];
+
+	  if (listeners.fn) {
+	    if (
+	      listeners.fn === fn &&
+	      (!once || listeners.once) &&
+	      (!context || listeners.context === context)
+	    ) {
+	      clearEvent(this, evt);
+	    }
+	  } else {
+	    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+	      if (
+	        listeners[i].fn !== fn ||
+	        (once && !listeners[i].once) ||
+	        (context && listeners[i].context !== context)
+	      ) {
+	        events.push(listeners[i]);
+	      }
+	    }
+
+	    //
+	    // Reset the array, or remove it completely if we have no more listeners.
+	    //
+	    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+	    else clearEvent(this, evt);
+	  }
+
+	  return this;
+	};
+
+	/**
+	 * Remove all listeners, or those of the specified event.
+	 *
+	 * @param {(String|Symbol)} [event] The event name.
+	 * @returns {EventEmitter} `this`.
+	 * @public
+	 */
+	EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+	  var evt;
+
+	  if (event) {
+	    evt = prefix ? prefix + event : event;
+	    if (this._events[evt]) clearEvent(this, evt);
+	  } else {
+	    this._events = new Events();
+	    this._eventsCount = 0;
+	  }
+
+	  return this;
+	};
+
+	//
+	// Alias methods names because people roll like that.
+	//
+	EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+	EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+	//
+	// Expose the prefix.
+	//
+	EventEmitter.prefixed = prefix;
+
+	//
+	// Allow `EventEmitter` to be imported as module namespace.
+	//
+	EventEmitter.EventEmitter = EventEmitter;
+
+	//
+	// Expose the module.
+	//
+	{
+	  module.exports = EventEmitter;
+	} 
+} (eventemitter3));
+
+var eventemitter3Exports = eventemitter3.exports;
+var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
+
+// Constants for the Aomi Chat Widget
+/*
+ * ============================================================================
+ * WIDGET DEFAULTS
+ * ============================================================================
+ */
+const DEFAULT_WIDGET_WIDTH = '400px';
+const DEFAULT_WIDGET_HEIGHT = '600px';
+const DEFAULT_MAX_HEIGHT = 800;
+const DEFAULT_MESSAGE_LENGTH = 2000;
+const DEFAULT_RECONNECT_ATTEMPTS = 5;
+const DEFAULT_RECONNECT_DELAY = 3000;
+/*
+ * ============================================================================
+ * NETWORK CONSTANTS
+ * ============================================================================
+ */
+const SUPPORTED_CHAINS = {
+    1: 'Ethereum',
+    5: 'Goerli',
+    10: 'Optimism',
+    100: 'Gnosis',
+    1337: 'Localhost',
+    31337: 'Anvil',
+    137: 'Polygon',
+    42161: 'Arbitrum One',
+    59140: 'Linea Sepolia',
+    59144: 'Linea',
+    8453: 'Base',
+    11155111: 'Sepolia',
+};
+const DEFAULT_CHAIN_ID = 1;
+/*
+ * ============================================================================
+ * THEME PALETTES
+ * ============================================================================
+ */
+const THEME_PALETTES = {
+    light: {
+        primary: '#007bff',
+        background: '#ffffff',
+        surface: '#f8f9fa',
+        text: '#212529',
+        textSecondary: '#6c757d',
+        border: '#dee2e6',
+        success: '#28a745',
+        error: '#dc3545',
+        warning: '#ffc107',
+        accent: '#6f42c1',
+    },
+    dark: {
+        primary: '#0d6efd',
+        background: '#121212',
+        surface: '#1e1e1e',
+        text: '#ffffff',
+        textSecondary: '#b3b3b3',
+        border: '#404040',
+        success: '#00d26a',
+        error: '#ff4757',
+        warning: '#ffa500',
+        accent: '#8b5cf6',
+    },
+    terminal: {
+        primary: '#00ff00',
+        background: '#0a0a0a',
+        surface: '#161b22',
+        text: '#00ff00',
+        textSecondary: '#22c55e',
+        border: '#30363d',
+        success: '#00ff88',
+        error: '#ff5555',
+        warning: '#ffff55',
+        accent: '#ff00ff',
+    },
+    neon: {
+        primary: '#ff007f',
+        background: '#0d0015',
+        surface: '#1a0033',
+        text: '#ffffff',
+        textSecondary: '#cc99ff',
+        border: '#4a0066',
+        success: '#00ffaa',
+        error: '#ff3366',
+        warning: '#ffaa00',
+        accent: '#00aaff',
+    },
+    minimal: {
+        primary: '#000000',
+        background: '#ffffff',
+        surface: '#fafafa',
+        text: '#333333',
+        textSecondary: '#888888',
+        border: '#e0e0e0',
+        success: '#4caf50',
+        error: '#f44336',
+        warning: '#ff9800',
+        accent: '#9c27b0',
+    },
+};
+/*
+ * ============================================================================
+ * COMPLETE THEME DEFINITIONS
+ * ============================================================================
+ */
+const PREDEFINED_THEMES = {
+    light: {
+        name: 'Light',
+        palette: THEME_PALETTES.light,
+        fonts: {
+            primary: '"Segoe UI", "Roboto", "Helvetica Neue", Arial, sans-serif',
+            monospace: '"SF Mono", "Monaco", "Inconsolata", "Roboto Mono", monospace',
+        },
+        spacing: {
+            xs: '4px',
+            sm: '8px',
+            md: '16px',
+            lg: '24px',
+            xl: '32px',
+        },
+        borderRadius: {
+            sm: '4px',
+            md: '8px',
+            lg: '12px',
+        },
+        shadows: {
+            sm: '0 1px 3px rgba(0, 0, 0, 0.1)',
+            md: '0 4px 12px rgba(0, 0, 0, 0.15)',
+            lg: '0 8px 24px rgba(0, 0, 0, 0.2)',
+        },
+    },
+    dark: {
+        name: 'Dark',
+        palette: THEME_PALETTES.dark,
+        fonts: {
+            primary: '"Segoe UI", "Roboto", "Helvetica Neue", Arial, sans-serif',
+            monospace: '"SF Mono", "Monaco", "Inconsolata", "Roboto Mono", monospace',
+        },
+        spacing: {
+            xs: '4px',
+            sm: '8px',
+            md: '16px',
+            lg: '24px',
+            xl: '32px',
+        },
+        borderRadius: {
+            sm: '4px',
+            md: '8px',
+            lg: '12px',
+        },
+        shadows: {
+            sm: '0 1px 3px rgba(0, 0, 0, 0.3)',
+            md: '0 4px 12px rgba(0, 0, 0, 0.4)',
+            lg: '0 8px 24px rgba(0, 0, 0, 0.5)',
+        },
+    },
+    terminal: {
+        name: 'Terminal',
+        palette: THEME_PALETTES.terminal,
+        fonts: {
+            primary: '"SF Mono", "Monaco", "Inconsolata", "Roboto Mono", monospace',
+            monospace: '"SF Mono", "Monaco", "Inconsolata", "Roboto Mono", monospace',
+        },
+        spacing: {
+            xs: '2px',
+            sm: '4px',
+            md: '8px',
+            lg: '16px',
+            xl: '24px',
+        },
+        borderRadius: {
+            sm: '0px',
+            md: '2px',
+            lg: '4px',
+        },
+        shadows: {
+            sm: '0 0 8px rgba(0, 255, 0, 0.3)',
+            md: '0 0 16px rgba(0, 255, 0, 0.5)',
+            lg: '0 0 24px rgba(0, 255, 0, 0.7)',
+        },
+    },
+    neon: {
+        name: 'Neon',
+        palette: THEME_PALETTES.neon,
+        fonts: {
+            primary: '"Orbitron", "Rajdhani", "Exo 2", sans-serif',
+            monospace: '"Share Tech Mono", "Courier New", monospace',
+        },
+        spacing: {
+            xs: '4px',
+            sm: '8px',
+            md: '16px',
+            lg: '24px',
+            xl: '32px',
+        },
+        borderRadius: {
+            sm: '2px',
+            md: '6px',
+            lg: '10px',
+        },
+        shadows: {
+            sm: '0 0 8px rgba(255, 0, 127, 0.4)',
+            md: '0 0 16px rgba(255, 0, 127, 0.6)',
+            lg: '0 0 24px rgba(255, 0, 127, 0.8)',
+        },
+    },
+    minimal: {
+        name: 'Minimal',
+        palette: THEME_PALETTES.minimal,
+        fonts: {
+            primary: '"Inter", "Helvetica Neue", Arial, sans-serif',
+            monospace: '"JetBrains Mono", "SF Mono", monospace',
+        },
+        spacing: {
+            xs: '4px',
+            sm: '8px',
+            md: '16px',
+            lg: '24px',
+            xl: '32px',
+        },
+        borderRadius: {
+            sm: '2px',
+            md: '4px',
+            lg: '6px',
+        },
+        shadows: {
+            sm: '0 1px 2px rgba(0, 0, 0, 0.05)',
+            md: '0 2px 8px rgba(0, 0, 0, 0.1)',
+            lg: '0 4px 16px rgba(0, 0, 0, 0.15)',
+        },
+    },
+};
+/*
+ * ============================================================================
+ * ERROR CODES
+ * ============================================================================
+ */
+const ERROR_CODES = {
+    // Configuration errors
+    INVALID_CONFIG: 'INVALID_CONFIG',
+    MISSING_APP_CODE: 'MISSING_APP_CODE',
+    INVALID_THEME: 'INVALID_THEME',
+    INVALID_DIMENSIONS: 'INVALID_DIMENSIONS',
+    // Connection errors
+    CONNECTION_FAILED: 'CONNECTION_FAILED',
+    CONNECTION_TIMEOUT: 'CONNECTION_TIMEOUT',
+    BACKEND_UNAVAILABLE: 'BACKEND_UNAVAILABLE',
+    AUTHENTICATION_FAILED: 'AUTHENTICATION_FAILED',
+    // Wallet errors
+    WALLET_NOT_CONNECTED: 'WALLET_NOT_CONNECTED',
+    WALLET_CONNECTION_FAILED: 'WALLET_CONNECTION_FAILED',
+    UNSUPPORTED_NETWORK: 'UNSUPPORTED_NETWORK',
+    TRANSACTION_FAILED: 'TRANSACTION_FAILED',
+    TRANSACTION_REJECTED: 'TRANSACTION_REJECTED',
+    // Chat errors
+    MESSAGE_TOO_LONG: 'MESSAGE_TOO_LONG',
+    RATE_LIMITED: 'RATE_LIMITED',
+    INVALID_MESSAGE: 'INVALID_MESSAGE',
+    SESSION_EXPIRED: 'SESSION_EXPIRED',
+    // General errors
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+    INITIALIZATION_FAILED: 'INITIALIZATION_FAILED',
+    PROVIDER_ERROR: 'PROVIDER_ERROR',
+};
+/*
+ * ============================================================================
+ * EVENT NAMES
+ * ============================================================================
+ */
+const WIDGET_EVENTS = {
+    // Widget lifecycle
+    READY: 'ready',
+    DESTROY: 'destroy',
+    RESIZE: 'resize',
+    // Chat events
+    MESSAGE: 'message',
+    TYPING_CHANGE: 'typingChange',
+    PROCESSING_CHANGE: 'processingChange',
+    // Connection events
+    CONNECTION_CHANGE: 'connectionChange',
+    SESSION_START: 'sessionStart',
+    SESSION_END: 'sessionEnd',
+    // Wallet events
+    WALLET_CONNECT: 'walletConnect',
+    WALLET_DISCONNECT: 'walletDisconnect',
+    NETWORK_CHANGE: 'networkChange',
+    TRANSACTION_REQUEST: 'transactionRequest',
+    // Error events
+    ERROR: 'error',
+};
+/*
+ * ============================================================================
+ * CSS CLASS NAMES
+ * ============================================================================
+ */
+const CSS_CLASSES = {
+    // Root classes
+    WIDGET_ROOT: 'aomi-chat-widget',
+    WIDGET_CONTAINER: 'aomi-chat-container',
+    WIDGET_IFRAME: 'aomi-chat-iframe',
+    // Theme classes
+    THEME_LIGHT: 'aomi-theme-light',
+    THEME_DARK: 'aomi-theme-dark',
+    THEME_TERMINAL: 'aomi-theme-terminal',
+    THEME_NEON: 'aomi-theme-neon',
+    THEME_MINIMAL: 'aomi-theme-minimal',
+    // Mode classes
+    MODE_FULL: 'aomi-mode-full',
+    MODE_MINIMAL: 'aomi-mode-minimal',
+    MODE_COMPACT: 'aomi-mode-compact',
+    MODE_TERMINAL: 'aomi-mode-terminal',
+    // Component classes
+    CHAT_INTERFACE: 'aomi-chat-interface',
+    CHAT_HEADER: 'aomi-chat-header',
+    CHAT_TITLE: 'aomi-chat-title',
+    CHAT_BODY: 'aomi-chat-body',
+    STATUS_BADGE: 'aomi-status-badge',
+    MESSAGE_LIST: 'aomi-message-list',
+    MESSAGE_CONTAINER: 'aomi-message-container',
+    MESSAGE_BUBBLE: 'aomi-message',
+    MESSAGE_USER: 'aomi-message-user',
+    MESSAGE_ASSISTANT: 'aomi-message-assistant',
+    MESSAGE_SYSTEM: 'aomi-message-system',
+    ACTION_BAR: 'aomi-action-bar',
+    MESSAGE_INPUT: 'aomi-message-input',
+    INPUT_FORM: 'aomi-chat-input-form',
+    INPUT_FIELD: 'aomi-chat-input-field',
+    SEND_BUTTON: 'aomi-chat-send-button',
+    WALLET_STATUS: 'aomi-wallet-status',
+    TYPING_INDICATOR: 'aomi-typing-indicator',
+    // State classes
+    LOADING: 'aomi-loading',
+    ERROR: 'aomi-error',
+    DISABLED: 'aomi-disabled',
+    CONNECTED: 'aomi-connected',
+    DISCONNECTED: 'aomi-disconnected',
+};
+/*
+ * ============================================================================
+ * API ENDPOINTS
+ * ============================================================================
+ */
+const API_ENDPOINTS = {
+    CHAT: '/api/chat',
+    CHAT_STREAM: '/api/chat/stream',
+    STATE: '/api/state',
+    INTERRUPT: '/api/interrupt',
+    SYSTEM: '/api/system',
+    MCP_COMMAND: '/api/mcp-command',
+    HEALTH: '/health',
+};
+/*
+ * ============================================================================
+ * TIMING CONSTANTS
+ * ============================================================================
+ */
+const TIMING = {
+    TYPING_INDICATOR_DELAY: 100,
+    MESSAGE_ANIMATION_DURATION: 300,
+    CONNECTION_TIMEOUT: 10000,
+    RETRY_DELAY: 1000,
+    HEARTBEAT_INTERVAL: 30000,
+    SESSION_TIMEOUT: 3600000, // 1 hour
+};
+
+// Error types and classes for the Aomi Chat Widget
+/*
+ * ============================================================================
+ * BASE ERROR CLASS
+ * ============================================================================
+ */
+class AomiChatError extends Error {
+    constructor(code, message, details) {
+        super(message);
+        this.name = 'AomiChatError';
+        this.code = code;
+        this.timestamp = new Date();
+        this.details = details;
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, AomiChatError);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            timestamp: this.timestamp.toISOString(),
+            details: this.details,
+            stack: this.stack,
+        };
+    }
+    toString() {
+        return `${this.name} [${this.code}]: ${this.message}`;
+    }
+}
+/*
+ * ============================================================================
+ * SPECIFIC ERROR CLASSES
+ * ============================================================================
+ */
+class ConfigurationError extends AomiChatError {
+    constructor(message, details) {
+        super(ERROR_CODES.INVALID_CONFIG, message, details);
+        this.name = 'ConfigurationError';
+    }
+}
+class ConnectionError extends AomiChatError {
+    constructor(message, details) {
+        super(ERROR_CODES.CONNECTION_FAILED, message, details);
+        this.name = 'ConnectionError';
+    }
+}
+class WalletError extends AomiChatError {
+    constructor(code, message, details) {
+        super(code, message, details);
+        this.name = 'WalletError';
+    }
+}
+class TransactionError extends WalletError {
+    constructor(message, details) {
+        super(ERROR_CODES.TRANSACTION_FAILED, message, details);
+        this.name = 'TransactionError';
+    }
+}
+class ChatError extends AomiChatError {
+    constructor(code, message, details) {
+        super(code, message, details);
+        this.name = 'ChatError';
+    }
+}
+class RateLimitError extends ChatError {
+    constructor(message, details) {
+        super(ERROR_CODES.RATE_LIMITED, message, details);
+        this.name = 'RateLimitError';
+    }
+}
+class SessionError extends AomiChatError {
+    constructor(message, details) {
+        super(ERROR_CODES.SESSION_EXPIRED, message, details);
+        this.name = 'SessionError';
+    }
+}
+/*
+ * ============================================================================
+ * ERROR FACTORY FUNCTIONS
+ * ============================================================================
+ */
+function createConfigurationError(message, details) {
+    return new ConfigurationError(message, details);
+}
+function createConnectionError(message, details) {
+    return new ConnectionError(message, details);
+}
+function createWalletError(code, message, details) {
+    return new WalletError(code, message, details);
+}
+function createTransactionError(message, details) {
+    return new TransactionError(message, details);
+}
+function createChatError(code, message, details) {
+    return new ChatError(code, message, details);
+}
+function createRateLimitError(message, details) {
+    return new RateLimitError(message, details);
+}
+function createSessionError(message, details) {
+    return new SessionError(message, details);
+}
+/*
+ * ============================================================================
+ * ERROR HANDLING UTILITIES
+ * ============================================================================
+ */
+function isAomiChatError(error) {
+    return error instanceof AomiChatError;
+}
+function isConfigurationError(error) {
+    return error instanceof ConfigurationError;
+}
+function isConnectionError(error) {
+    return error instanceof ConnectionError;
+}
+function isWalletError(error) {
+    return error instanceof WalletError;
+}
+function isTransactionError(error) {
+    return error instanceof TransactionError;
+}
+function isChatError(error) {
+    return error instanceof ChatError;
+}
+function isRateLimitError(error) {
+    return error instanceof RateLimitError;
+}
+function isSessionError(error) {
+    return error instanceof SessionError;
+}
+/*
+ * ============================================================================
+ * ERROR SEVERITY LEVELS
+ * ============================================================================
+ */
+/* eslint-disable no-unused-vars, @typescript-eslint/no-unused-vars */
+var ErrorSeverity;
+(function (ErrorSeverity) {
+    ErrorSeverity["LOW"] = "low";
+    ErrorSeverity["MEDIUM"] = "medium";
+    ErrorSeverity["HIGH"] = "high";
+    ErrorSeverity["CRITICAL"] = "critical";
+})(ErrorSeverity || (ErrorSeverity = {}));
+/*
+ * ============================================================================
+ * ERROR MESSAGES
+ * ============================================================================
+ */
+({
+    [ERROR_CODES.INVALID_CONFIG]: 'Invalid widget configuration provided',
+    [ERROR_CODES.MISSING_APP_CODE]: 'App code is required for widget initialization',
+    [ERROR_CODES.INVALID_THEME]: 'Invalid theme configuration',
+    [ERROR_CODES.INVALID_DIMENSIONS]: 'Invalid widget dimensions',
+    [ERROR_CODES.CONNECTION_FAILED]: 'Failed to connect to the chat backend',
+    [ERROR_CODES.CONNECTION_TIMEOUT]: 'Connection timed out',
+    [ERROR_CODES.BACKEND_UNAVAILABLE]: 'Chat backend is currently unavailable',
+    [ERROR_CODES.AUTHENTICATION_FAILED]: 'Authentication failed',
+    [ERROR_CODES.WALLET_NOT_CONNECTED]: 'Wallet is not connected',
+    [ERROR_CODES.WALLET_CONNECTION_FAILED]: 'Failed to connect to wallet',
+    [ERROR_CODES.UNSUPPORTED_NETWORK]: 'Unsupported network',
+    [ERROR_CODES.TRANSACTION_FAILED]: 'Transaction failed',
+    [ERROR_CODES.TRANSACTION_REJECTED]: 'Transaction was rejected by user',
+    [ERROR_CODES.MESSAGE_TOO_LONG]: 'Message exceeds maximum length',
+    [ERROR_CODES.RATE_LIMITED]: 'Rate limit exceeded, please slow down',
+    [ERROR_CODES.INVALID_MESSAGE]: 'Invalid message format',
+    [ERROR_CODES.SESSION_EXPIRED]: 'Chat session has expired',
+    [ERROR_CODES.UNKNOWN_ERROR]: 'An unknown error occurred',
+    [ERROR_CODES.INITIALIZATION_FAILED]: 'Widget initialization failed',
+    [ERROR_CODES.PROVIDER_ERROR]: 'Provider error occurred',
+});
+/*
+ * ============================================================================
+ * ERROR RECOVERY STRATEGIES
+ * ============================================================================
+ */
+var RecoveryStrategy;
+(function (RecoveryStrategy) {
+    RecoveryStrategy["RETRY"] = "retry";
+    RecoveryStrategy["RECONNECT"] = "reconnect";
+    RecoveryStrategy["REFRESH"] = "refresh";
+    RecoveryStrategy["FALLBACK"] = "fallback";
+    RecoveryStrategy["MANUAL"] = "manual";
+    RecoveryStrategy["NONE"] = "none";
+})(RecoveryStrategy || (RecoveryStrategy = {}));
+
+/* eslint-disable no-unused-vars, @typescript-eslint/no-unused-vars */
+// Core type definitions for Aomi Chat Widget
+/*
+ * ============================================================================
+ * WIDGET STATE TYPES
+ * ============================================================================
+ */
+var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus["CONNECTING"] = "connecting";
+    ConnectionStatus["CONNECTED"] = "connected";
+    ConnectionStatus["DISCONNECTED"] = "disconnected";
+    ConnectionStatus["ERROR"] = "error";
+    ConnectionStatus["RECONNECTING"] = "reconnecting";
+})(ConnectionStatus || (ConnectionStatus = {}));
+var ReadinessPhase;
+(function (ReadinessPhase) {
+    ReadinessPhase["INITIALIZING"] = "initializing";
+    ReadinessPhase["CONNECTING_MCP"] = "connecting_mcp";
+    ReadinessPhase["VALIDATING_ANTHROPIC"] = "validating_anthropic";
+    ReadinessPhase["READY"] = "ready";
+    ReadinessPhase["MISSING_API_KEY"] = "missing_api_key";
+    ReadinessPhase["ERROR"] = "error";
+})(ReadinessPhase || (ReadinessPhase = {}));
+/* eslint-enable no-unused-vars, @typescript-eslint/no-unused-vars */
+
+// Utility functions for the Aomi Chat Widget
+/*
+ * ============================================================================
+ * CONFIGURATION UTILITIES
+ * ============================================================================
+ */
+/**
+ * Resolves a flexible configuration value based on chain ID and mode
+ */
+function resolveFlexibleConfig(config, chainId, mode) {
+    // If it's a simple value, return it
+    if (typeof config !== 'object' || config === null) {
+        return config;
+    }
+    // Check if it's a per-mode configuration
+    if (isPerModeConfig(config)) {
+        const modeValue = config[mode];
+        if (modeValue === undefined) {
+            return undefined;
+        }
+        // If the mode value is itself a per-network config
+        if (isPerNetworkConfig(modeValue)) {
+            return modeValue[chainId];
+        }
+        return modeValue;
+    }
+    // Check if it's a per-network configuration
+    if (isPerNetworkConfig(config)) {
+        const networkValue = config[chainId];
+        if (networkValue === undefined) {
+            return undefined;
+        }
+        // If the network value is itself a per-mode config
+        if (isPerModeConfig(networkValue)) {
+            return networkValue[mode];
+        }
+        return networkValue;
+    }
+    return config;
+}
+function isPerModeConfig(config) {
+    if (typeof config !== 'object' || config === null)
+        return false;
+    const modes = ['full', 'minimal', 'compact', 'terminal'];
+    const keys = Object.keys(config);
+    return keys.length > 0 && keys.every(key => modes.includes(key));
+}
+function isPerNetworkConfig(config) {
+    if (typeof config !== 'object' || config === null)
+        return false;
+    const chainIds = Object.keys(SUPPORTED_CHAINS).map(id => parseInt(id));
+    const keys = Object.keys(config).map(key => parseInt(key));
+    return keys.length > 0 && keys.every(key => chainIds.includes(key));
+}
+/*
+ * ============================================================================
+ * VALIDATION UTILITIES
+ * ============================================================================
+ */
+/**
+ * Validates widget configuration parameters
+ */
+function validateWidgetParams(params) {
+    const errors = [];
+    // Required fields
+    if (!params.appCode || typeof params.appCode !== 'string') {
+        errors.push('appCode is required and must be a string');
+    }
+    // Validate dimensions
+    if (params.width && !isValidDimension(params.width)) {
+        errors.push('width must be a valid CSS dimension (e.g., "400px", "100%")');
+    }
+    if (params.height && !isValidDimension(params.height)) {
+        errors.push('height must be a valid CSS dimension (e.g., "600px", "100vh")');
+    }
+    if (params.maxHeight && (typeof params.maxHeight !== 'number' || params.maxHeight <= 0)) {
+        errors.push('maxHeight must be a positive number');
+    }
+    // Validate chain ID
+    if (params.chainId && !Object.keys(SUPPORTED_CHAINS).includes(params.chainId.toString())) {
+        errors.push(`chainId must be one of: ${Object.keys(SUPPORTED_CHAINS).join(', ')}`);
+    }
+    // Validate supported chains
+    if (params.supportedChains) {
+        const invalidChains = params.supportedChains.filter(id => !Object.keys(SUPPORTED_CHAINS).includes(id.toString()));
+        if (invalidChains.length > 0) {
+            errors.push(`supportedChains contains invalid chain IDs: ${invalidChains.join(', ')}`);
+        }
+    }
+    // Validate theme
+    if (params.theme && !isValidTheme(params.theme)) {
+        errors.push('theme must be a valid theme name or theme palette object');
+    }
+    // Validate mode
+    if (params.mode && !['full', 'minimal', 'compact', 'terminal'].includes(params.mode)) {
+        errors.push('mode must be one of: full, minimal, compact, terminal');
+    }
+    return errors;
+}
+function isValidDimension(dimension) {
+    // Simple regex to validate CSS dimensions
+    return /^(\d+(\.\d+)?(px|%|em|rem|vh|vw)|auto|inherit)$/.test(dimension);
+}
+function isValidTheme(theme) {
+    if (typeof theme === 'string') {
+        return Object.keys(PREDEFINED_THEMES).includes(theme);
+    }
+    if (typeof theme === 'object' && theme !== null) {
+        return 'baseTheme' in theme && typeof theme.baseTheme === 'string';
+    }
+    return false;
+}
+/*
+ * ============================================================================
+ * SESSION UTILITIES
+ * ============================================================================
+ */
+/**
+ * Generates a unique session ID
+ */
+function generateSessionId() {
+    // Use crypto.randomUUID if available (modern browsers)
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    // Fallback UUID v4 implementation
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
+/**
+ * Validates a session ID format
+ */
+function isValidSessionId(sessionId) {
+    // UUID v4 format
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(sessionId);
+}
+/*
+ * ============================================================================
+ * URL UTILITIES
+ * ============================================================================
+ */
+/**
+ * Builds widget URL with parameters
+ */
+function buildWidgetUrl(baseUrl, params) {
+    const url = new URL('/widget', baseUrl);
+    // Add essential parameters
+    url.searchParams.set('appCode', params.appCode);
+    if (params.sessionId) {
+        url.searchParams.set('sessionId', params.sessionId);
+    }
+    if (params.theme) {
+        if (typeof params.theme === 'string') {
+            url.searchParams.set('theme', params.theme);
+        }
+        else {
+            // For complex theme objects, encode as JSON
+            url.searchParams.set('palette', JSON.stringify(params.theme));
+        }
+    }
+    if (params.mode) {
+        url.searchParams.set('mode', params.mode);
+    }
+    if (params.chainId) {
+        url.searchParams.set('chainId', params.chainId.toString());
+    }
+    if (params.welcomeMessage) {
+        url.searchParams.set('welcomeMessage', params.welcomeMessage);
+    }
+    if (params.placeholder) {
+        url.searchParams.set('placeholder', params.placeholder);
+    }
+    // Boolean flags
+    if (params.showWalletStatus === false) {
+        url.searchParams.set('showWalletStatus', 'false');
+    }
+    if (params.showNetworkSelector === false) {
+        url.searchParams.set('showNetworkSelector', 'false');
+    }
+    if (params.hideHeader) {
+        url.searchParams.set('hideHeader', 'true');
+    }
+    if (params.hideFooter) {
+        url.searchParams.set('hideFooter', 'true');
+    }
+    if (params.enableTransactions === false) {
+        url.searchParams.set('enableTransactions', 'false');
+    }
+    if (params.requireWalletConnection) {
+        url.searchParams.set('requireWalletConnection', 'true');
+    }
+    if (params.standaloneMode === false) {
+        url.searchParams.set('standaloneMode', 'false');
+    }
+    return url.toString();
+}
+/**
+ * Parses widget parameters from URL search params
+ */
+function parseWidgetParams(searchParams) {
+    const params = {};
+    const appCode = searchParams.get('appCode');
+    if (appCode)
+        params.appCode = appCode;
+    const sessionId = searchParams.get('sessionId');
+    if (sessionId)
+        params.sessionId = sessionId;
+    const theme = searchParams.get('theme');
+    if (theme)
+        params.theme = theme;
+    const palette = searchParams.get('palette');
+    if (palette) {
+        try {
+            params.theme = JSON.parse(palette);
+        }
+        catch {
+            // Ignore invalid JSON
+        }
+    }
+    const mode = searchParams.get('mode');
+    if (mode)
+        params.mode = mode;
+    const chainId = searchParams.get('chainId');
+    if (chainId) {
+        const parsed = parseInt(chainId);
+        if (!isNaN(parsed))
+            params.chainId = parsed;
+    }
+    const welcomeMessage = searchParams.get('welcomeMessage');
+    if (welcomeMessage)
+        params.welcomeMessage = welcomeMessage;
+    const placeholder = searchParams.get('placeholder');
+    if (placeholder)
+        params.placeholder = placeholder;
+    // Boolean parameters
+    const showWalletStatus = searchParams.get('showWalletStatus');
+    if (showWalletStatus === 'false')
+        params.showWalletStatus = false;
+    const showNetworkSelector = searchParams.get('showNetworkSelector');
+    if (showNetworkSelector === 'false')
+        params.showNetworkSelector = false;
+    const hideHeader = searchParams.get('hideHeader');
+    if (hideHeader === 'true')
+        params.hideHeader = true;
+    const hideFooter = searchParams.get('hideFooter');
+    if (hideFooter === 'true')
+        params.hideFooter = true;
+    const enableTransactions = searchParams.get('enableTransactions');
+    if (enableTransactions === 'false')
+        params.enableTransactions = false;
+    const requireWalletConnection = searchParams.get('requireWalletConnection');
+    if (requireWalletConnection === 'true')
+        params.requireWalletConnection = true;
+    const standaloneMode = searchParams.get('standaloneMode');
+    if (standaloneMode === 'false')
+        params.standaloneMode = false;
+    return params;
+}
+/*
+ * ============================================================================
+ * DOM UTILITIES
+ * ============================================================================
+ */
+/**
+ * Creates a DOM element with classes and attributes
+ */
+function createElement(tagName, options = {}) {
+    const element = document.createElement(tagName);
+    // Set classes
+    if (options.className) {
+        if (Array.isArray(options.className)) {
+            element.classList.add(...options.className);
+        }
+        else {
+            element.className = options.className;
+        }
+    }
+    // Set attributes
+    if (options.attributes) {
+        Object.entries(options.attributes).forEach(([key, value]) => {
+            element.setAttribute(key, value);
+        });
+    }
+    // Set styles
+    if (options.styles) {
+        Object.assign(element.style, options.styles);
+    }
+    // Add children
+    if (options.children) {
+        options.children.forEach(child => {
+            if (typeof child === 'string') {
+                element.appendChild(document.createTextNode(child));
+            }
+            else {
+                element.appendChild(child);
+            }
+        });
+    }
+    return element;
+}
+/**
+ * Checks if an element is visible in the viewport
+ */
+function isElementVisible(element) {
+    const rect = element.getBoundingClientRect();
+    return (rect.top >= 0 &&
+        rect.left >= 0 &&
+        rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
+        rect.right <= (window.innerWidth || document.documentElement.clientWidth));
+}
+/*
+ * ============================================================================
+ * TYPE GUARDS
+ * ============================================================================
+ */
+/**
+ * Type guard to check if a value is a valid Ethereum address
+ */
+function isEthereumAddress(value) {
+    if (typeof value !== 'string')
+        return false;
+    return /^0x[a-fA-F0-9]{40}$/.test(value);
+}
+/**
+ * Type guard to check if a value is a valid transaction hash
+ */
+function isTransactionHash(value) {
+    if (typeof value !== 'string')
+        return false;
+    return /^0x[a-fA-F0-9]{64}$/.test(value);
+}
+/**
+ * Type guard to check if an object has a specific property
+ */
+function hasProperty(obj, prop) {
+    return prop in obj;
+}
+/*
+ * ============================================================================
+ * ASYNC UTILITIES
+ * ============================================================================
+ */
+/**
+ * Delays execution for a specified number of milliseconds
+ */
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Creates a promise that rejects after a timeout
+ */
+function withTimeout(promise, timeoutMs) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Operation timed out')), timeoutMs)),
+    ]);
+}
+/**
+ * Retries a function with exponential backoff
+ */
+async function retry(fn, options = {}) {
+    const { maxAttempts = 3, delay: initialDelay = 1000, backoffFactor = 2, shouldRetry = () => true, } = options;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === maxAttempts || !shouldRetry(error)) {
+                throw error;
+            }
+            const delayMs = initialDelay * Math.pow(backoffFactor, attempt - 1);
+            await delay(delayMs);
+        }
+    }
+    throw lastError;
+}
+/*
+ * ============================================================================
+ * ENVIRONMENT UTILITIES
+ * ============================================================================
+ */
+/**
+ * Detects if running in a browser environment
+ */
+function isBrowser() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+/**
+ * Detects if running on a mobile device
+ */
+function isMobile() {
+    if (!isBrowser())
+        return false;
+    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}
+/**
+ * Gets the current viewport dimensions
+ */
+function getViewportDimensions() {
+    if (!isBrowser()) {
+        return { width: 0, height: 0 };
+    }
+    return {
+        width: window.innerWidth || document.documentElement.clientWidth,
+        height: window.innerHeight || document.documentElement.clientHeight,
+    };
+}
+/*
+ * ============================================================================
+ * FORMATTING UTILITIES
+ * ============================================================================
+ */
+/**
+ * Formats a timestamp as a human-readable string
+ */
+function formatTimestamp(timestamp) {
+    const now = new Date();
+    const diff = now.getTime() - timestamp.getTime();
+    if (diff < 60000) { // Less than 1 minute
+        return 'just now';
+    }
+    else if (diff < 3600000) { // Less than 1 hour
+        const minutes = Math.floor(diff / 60000);
+        return `${minutes} minute${minutes > 1 ? 's' : ''} ago`;
+    }
+    else if (diff < 86400000) { // Less than 1 day
+        const hours = Math.floor(diff / 3600000);
+        return `${hours} hour${hours > 1 ? 's' : ''} ago`;
+    }
+    else {
+        return timestamp.toLocaleDateString();
+    }
+}
+/**
+ * Truncates an Ethereum address for display
+ */
+function truncateAddress(address, startChars = 6, endChars = 4) {
+    if (!isEthereumAddress(address))
+        return address;
+    if (address.length <= startChars + endChars)
+        return address;
+    return `${address.slice(0, startChars)}...${address.slice(-endChars)}`;
+}
+/**
+ * Formats a number with appropriate decimal places
+ */
+function formatNumber(value, options = {}) {
+    const { decimals = 2, compact = false, currency } = options;
+    const formatter = new Intl.NumberFormat('en-US', {
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals,
+        notation: compact ? 'compact' : 'standard',
+        style: currency ? 'currency' : 'decimal',
+        currency: currency || 'USD',
+    });
+    return formatter.format(value);
+}
+
+/*
+ * ChatManager - Aligns widget behaviour with the updated frontend core logic
+ */
+class ChatManager extends EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.eventSource = null;
+        this.reconnectAttempt = 0;
+        this.reconnectTimer = null;
+        this.heartbeatTimer = null;
+        this.lastPendingTransactionRaw = null;
+        this.config = {
+            backendUrl: config.backendUrl || 'http://localhost:8080',
+            sessionId: config.sessionId || generateSessionId(),
+            maxMessageLength: config.maxMessageLength || 2000,
+            reconnectAttempts: config.reconnectAttempts || 5,
+            reconnectDelay: config.reconnectDelay || 3000,
+        };
+        this.state = {
+            messages: [],
+            isTyping: false,
+            isProcessing: false,
+            connectionStatus: ConnectionStatus.DISCONNECTED,
+            readiness: {
+                phase: ReadinessPhase.INITIALIZING,
+            },
+            walletState: {
+                isConnected: false,
+            },
+            sessionId: this.config.sessionId,
+            pendingTransaction: undefined,
+        };
+    }
+    /*
+     * ============================================================================
+     * PUBLIC API
+     * ============================================================================
+     */
+    getState() {
+        return {
+            ...this.state,
+            messages: [...this.state.messages],
+            walletState: { ...this.state.walletState },
+        };
+    }
+    getSessionId() {
+        return this.config.sessionId;
+    }
+    setSessionId(sessionId) {
+        this.config.sessionId = sessionId;
+        this.state.sessionId = sessionId;
+        if (this.state.connectionStatus === ConnectionStatus.CONNECTED) {
+            void this.connectSSE();
+        }
+    }
+    async connectSSE() {
+        this.setConnectionStatus(ConnectionStatus.CONNECTING);
+        this.updateReadiness({ phase: ReadinessPhase.CONNECTING_MCP });
+        this.teardownEventSource();
+        try {
+            const streamUrl = `${this.config.backendUrl}${API_ENDPOINTS.CHAT_STREAM}?session_id=${encodeURIComponent(this.config.sessionId)}`;
+            this.eventSource = new EventSource(streamUrl);
+            this.eventSource.onopen = () => {
+                this.setConnectionStatus(ConnectionStatus.CONNECTED);
+                this.reconnectAttempt = 0;
+                this.startHeartbeat();
+                void this.refreshState();
+            };
+            this.eventSource.onmessage = (event) => {
+                try {
+                    const payload = JSON.parse(event.data);
+                    this.processBackendPayload(payload);
+                }
+                catch (error) {
+                    console.error('Failed to parse SSE payload:', error);
+                    this.emit('error', createChatError(ERROR_CODES.INVALID_MESSAGE, 'Invalid message format'));
+                }
+            };
+            this.eventSource.onerror = (event) => {
+                console.error('SSE connection error:', event);
+                if (this.state.isProcessing) {
+                    this.state.isProcessing = false;
+                    this.state.isTyping = false;
+                    this.emitStateChange();
+                }
+                this.handleConnectionError();
+                void this.refreshState();
+            };
+        }
+        catch (error) {
+            console.error('Failed to create SSE connection:', error);
+            this.emit('error', createConnectionError('Failed to establish connection'));
+            this.handleConnectionError();
+        }
+    }
+    disconnectSSE() {
+        this.teardownEventSource();
+        this.setConnectionStatus(ConnectionStatus.DISCONNECTED);
+    }
+    async sendMessage(message) {
+        const content = message.trim();
+        if (!content) {
+            throw createChatError(ERROR_CODES.INVALID_MESSAGE, 'Message cannot be empty');
+        }
+        if (content.length > (this.config.maxMessageLength ?? 0)) {
+            throw createChatError(ERROR_CODES.MESSAGE_TOO_LONG, `Message exceeds ${this.config.maxMessageLength} characters`);
+        }
+        if (this.state.connectionStatus !== ConnectionStatus.CONNECTED) {
+            throw createConnectionError('Not connected to backend');
+        }
+        try {
+            const response = await this.postToBackend(API_ENDPOINTS.CHAT, {
+                message: content,
+                session_id: this.config.sessionId,
+            });
+            this.processBackendPayload(response);
+        }
+        catch (error) {
+            console.error('Failed to send message:', error);
+            throw createChatError(ERROR_CODES.UNKNOWN_ERROR, 'Failed to send message');
+        }
+    }
+    async sendSystemMessage(message) {
+        try {
+            const response = await this.postToBackend(API_ENDPOINTS.SYSTEM, {
+                message,
+                session_id: this.config.sessionId,
+            });
+            this.processBackendPayload(response);
+        }
+        catch (error) {
+            console.error('Failed to send system message:', error);
+            throw createChatError(ERROR_CODES.UNKNOWN_ERROR, 'Failed to send system message');
+        }
+    }
+    async interrupt() {
+        try {
+            const response = await this.postToBackend(API_ENDPOINTS.INTERRUPT, {
+                session_id: this.config.sessionId,
+            });
+            this.processBackendPayload(response);
+        }
+        catch (error) {
+            console.error('Failed to interrupt:', error);
+            throw createChatError(ERROR_CODES.UNKNOWN_ERROR, 'Failed to interrupt processing');
+        }
+    }
+    async sendNetworkSwitchRequest(networkName) {
+        try {
+            await this.sendSystemMessage(`Detected user's wallet connected to ${networkName} network`);
+            return {
+                success: true,
+                message: `Network switch system message sent for ${networkName}`,
+                data: { network: networkName },
+            };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                message: err,
+            };
+        }
+    }
+    async sendTransactionResult(success, transactionHash, error) {
+        const message = success
+            ? `Transaction sent: ${transactionHash}`
+            : `Transaction rejected by user${error ? `: ${error}` : ''}`;
+        try {
+            await this.sendSystemMessage(message);
+        }
+        catch (err) {
+            console.error('Failed to send transaction result:', err);
+        }
+        finally {
+            this.clearPendingTransaction();
+        }
+    }
+    clearPendingTransaction() {
+        if (this.state.pendingTransaction) {
+            this.state.pendingTransaction = undefined;
+            this.lastPendingTransactionRaw = null;
+            this.emitStateChange();
+        }
+    }
+    clearMessages() {
+        if (this.state.messages.length === 0)
+            return;
+        this.state.messages = [];
+        this.emitStateChange();
+    }
+    updateWalletState(walletState) {
+        this.state.walletState = { ...this.state.walletState, ...walletState };
+        this.emitStateChange();
+    }
+    destroy() {
+        this.disconnectSSE();
+        this.removeAllListeners();
+    }
+    /*
+     * ============================================================================
+     * INTERNAL STATE HANDLING
+     * ============================================================================
+     */
+    processBackendPayload(payload) {
+        if (!payload) {
+            return;
+        }
+        const previousMessages = this.state.messages;
+        let stateChanged = false;
+        if (Array.isArray(payload.messages)) {
+            const nextMessages = this.buildMessages(payload.messages, previousMessages);
+            this.state.messages = nextMessages;
+            stateChanged = true;
+            nextMessages.forEach((message, index) => {
+                const previous = previousMessages[index];
+                const isNewMessage = !previous || previous.id !== message.id;
+                const contentChanged = previous && previous.content !== message.content;
+                const toolStreamChanged = previous && !areToolStreamsEqual(previous.toolStream, message.toolStream);
+                if (isNewMessage || contentChanged || toolStreamChanged) {
+                    this.emit('message', message);
+                }
+            });
+        }
+        else if (payload.messages === null) {
+            if (previousMessages.length > 0) {
+                this.state.messages = [];
+                stateChanged = true;
+            }
+        }
+        else if (payload.messages !== undefined) {
+            console.error('Received malformed messages payload from backend:', payload.messages);
+        }
+        if (payload.is_processing !== undefined) {
+            const processing = Boolean(payload.is_processing);
+            if (processing !== this.state.isProcessing) {
+                this.state.isProcessing = processing;
+                stateChanged = true;
+            }
+            if (this.state.isTyping !== processing) {
+                this.state.isTyping = processing;
+                stateChanged = true;
+            }
+        }
+        if (payload.readiness !== undefined) {
+            const readiness = this.normaliseReadiness(payload.readiness);
+            if (readiness) {
+                const current = this.state.readiness;
+                if (current.phase !== readiness.phase ||
+                    current.detail !== readiness.detail) {
+                    this.state.readiness = readiness;
+                    stateChanged = true;
+                }
+            }
+        }
+        if (payload.pending_wallet_tx !== undefined) {
+            if (payload.pending_wallet_tx === null) {
+                if (this.state.pendingTransaction) {
+                    this.state.pendingTransaction = undefined;
+                    this.lastPendingTransactionRaw = null;
+                    stateChanged = true;
+                }
+            }
+            else if (payload.pending_wallet_tx !== this.lastPendingTransactionRaw) {
+                try {
+                    const transaction = JSON.parse(payload.pending_wallet_tx);
+                    this.state.pendingTransaction = transaction;
+                    this.lastPendingTransactionRaw = payload.pending_wallet_tx;
+                    this.emit('transactionRequest', transaction);
+                    stateChanged = true;
+                }
+                catch (error) {
+                    console.error('Failed to parse wallet transaction payload:', error);
+                }
+            }
+        }
+        if ('pending_wallet_tx' in payload) {
+            const raw = payload.pending_wallet_tx ?? null;
+            if (raw === null) {
+                if (this.state.pendingTransaction) {
+                    this.state.pendingTransaction = undefined;
+                    this.lastPendingTransactionRaw = null;
+                    stateChanged = true;
+                }
+            }
+            else if (raw !== this.lastPendingTransactionRaw) {
+                this.lastPendingTransactionRaw = raw;
+                try {
+                    const parsed = JSON.parse(raw);
+                    this.state.pendingTransaction = parsed;
+                    stateChanged = true;
+                    this.emit('transactionRequest', parsed);
+                }
+                catch (error) {
+                    console.error('Failed to parse wallet transaction request:', error);
+                }
+            }
+        }
+        if (stateChanged) {
+            this.emitStateChange();
+        }
+    }
+    buildMessages(messages, previousMessages) {
+        return messages
+            .filter((msg) => Boolean(msg))
+            .map((msg, index) => {
+            const type = this.normaliseSender(msg.sender);
+            const content = msg.content ?? '';
+            const timestamp = this.parseTimestamp(msg.timestamp);
+            const toolStream = normaliseToolStream(msg.tool_stream);
+            const previous = previousMessages[index];
+            const id = previous ? previous.id : generateSessionId();
+            return {
+                id,
+                type,
+                content,
+                timestamp,
+                toolStream,
+            };
+        });
+    }
+    normaliseSender(sender) {
+        switch (sender) {
+            case 'user':
+                return 'user';
+            case 'system':
+                return 'system';
+            default:
+                return 'assistant';
+        }
+    }
+    parseTimestamp(timestamp) {
+        if (!timestamp) {
+            return new Date();
+        }
+        const parsed = new Date(timestamp);
+        if (Number.isNaN(parsed.valueOf())) {
+            return new Date();
+        }
+        return parsed;
+    }
+    normaliseReadiness(payload) {
+        if (!payload || typeof payload.phase !== 'string') {
+            return null;
+        }
+        const detailRaw = typeof payload.detail === 'string' && payload.detail.trim().length > 0
+            ? payload.detail.trim()
+            : typeof payload.message === 'string' && payload.message.trim().length > 0
+                ? payload.message.trim()
+                : undefined;
+        switch (payload.phase) {
+            case 'connecting_mcp':
+                return { phase: ReadinessPhase.CONNECTING_MCP, detail: detailRaw };
+            case 'validating_anthropic':
+                return { phase: ReadinessPhase.VALIDATING_ANTHROPIC, detail: detailRaw };
+            case 'ready':
+                return { phase: ReadinessPhase.READY, detail: detailRaw };
+            case 'missing_api_key':
+                return { phase: ReadinessPhase.MISSING_API_KEY, detail: detailRaw };
+            case 'error':
+                return { phase: ReadinessPhase.ERROR, detail: detailRaw };
+            default:
+                return { phase: ReadinessPhase.ERROR, detail: detailRaw };
+        }
+    }
+    updateReadiness(readiness) {
+        this.state.readiness = readiness;
+        this.emitStateChange();
+    }
+    setConnectionStatus(status) {
+        if (this.state.connectionStatus !== status) {
+            this.state.connectionStatus = status;
+            this.emit('connectionChange', status);
+            this.emitStateChange();
+        }
+    }
+    emitStateChange() {
+        this.emit('stateChange', this.getState());
+    }
+    /*
+     * ============================================================================
+     * BACKEND COMMUNICATION
+     * ============================================================================
+     */
+    async postToBackend(endpoint, data) {
+        const url = `${this.config.backendUrl}${endpoint}`;
+        try {
+            const response = await withTimeout(fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(data),
+            }), TIMING.CONNECTION_TIMEOUT);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('timed out')) {
+                throw createConnectionError('Request timed out');
+            }
+            throw createConnectionError(`Request failed: ${error}`);
+        }
+    }
+    async refreshState() {
+        try {
+            const response = await withTimeout(fetch(`${this.config.backendUrl}${API_ENDPOINTS.STATE}?session_id=${encodeURIComponent(this.config.sessionId)}`), TIMING.CONNECTION_TIMEOUT);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const payload = await response.json();
+            this.processBackendPayload(payload);
+        }
+        catch (error) {
+            console.warn('Failed to refresh chat state:', error);
+        }
+    }
+    /*
+     * ============================================================================
+     * CONNECTION MANAGEMENT
+     * ============================================================================
+     */
+    handleConnectionError() {
+        this.setConnectionStatus(ConnectionStatus.ERROR);
+        this.stopHeartbeat();
+        if (this.reconnectAttempt < (this.config.reconnectAttempts ?? 0)) {
+            this.scheduleReconnect();
+        }
+        else {
+            this.updateReadiness({ phase: ReadinessPhase.ERROR, detail: 'Connection lost' });
+            this.setConnectionStatus(ConnectionStatus.DISCONNECTED);
+            this.emit('error', createConnectionError('Max reconnection attempts reached'));
+            this.setConnectionStatus(ConnectionStatus.DISCONNECTED);
+        }
+    }
+    scheduleReconnect() {
+        this.clearReconnectTimer();
+        this.setConnectionStatus(ConnectionStatus.RECONNECTING);
+        this.updateReadiness({ phase: ReadinessPhase.CONNECTING_MCP });
+        const delay = (this.config.reconnectDelay ?? 0) * Math.pow(2, this.reconnectAttempt);
+        this.reconnectAttempt += 1;
+        this.reconnectTimer = setTimeout(() => {
+            void this.connectSSE();
+        }, delay);
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.state.connectionStatus === ConnectionStatus.CONNECTED && this.eventSource) {
+                if (this.eventSource.readyState !== EventSource.OPEN) {
+                    console.warn('SSE connection lost, attempting to reconnect');
+                    this.handleConnectionError();
+                }
+            }
+        }, TIMING.HEARTBEAT_INTERVAL);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    teardownEventSource() {
+        if (this.eventSource) {
+            this.eventSource.close();
+            this.eventSource = null;
+        }
+        this.stopHeartbeat();
+        this.clearReconnectTimer();
+    }
+}
+function normaliseToolStream(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    if (Array.isArray(raw)) {
+        const [topic, content] = raw;
+        return typeof topic === 'string'
+            ? { topic, content: typeof content === 'string' ? content : '' }
+            : undefined;
+    }
+    if (typeof raw === 'object') {
+        const { topic, content } = raw;
+        return typeof topic === 'string'
+            ? { topic, content: typeof content === 'string' ? content : '' }
+            : undefined;
+    }
+    return undefined;
+}
+function areToolStreamsEqual(a, b) {
+    if (!a && !b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
+    }
+    return a.topic === b.topic && a.content === b.content;
+}
+
+// ThemeManager - Handles theme configuration and application
+/*
+ * ============================================================================
+ * THEME MANAGER CLASS
+ * ============================================================================
+ */
+class ThemeManager {
+    constructor(theme) {
+        this.customPalette = null;
+        this.currentTheme = this.resolveTheme(theme);
+    }
+    /*
+     * ============================================================================
+     * PUBLIC API
+     * ============================================================================
+     */
+    /**
+     * Updates the current theme
+     */
+    updateTheme(theme) {
+        this.currentTheme = this.resolveTheme(theme);
+        this.customPalette = this.isCustomPalette(theme) ? theme : null;
+    }
+    /**
+     * Gets the current computed theme
+     */
+    getComputedTheme() {
+        if (this.customPalette) {
+            return {
+                ...this.currentTheme,
+                palette: this.customPalette,
+            };
+        }
+        return this.currentTheme;
+    }
+    /**
+     * Gets a specific color from the current theme
+     */
+    getColor(colorKey) {
+        const theme = this.getComputedTheme();
+        return theme.palette[colorKey] || THEME_PALETTES.light[colorKey];
+    }
+    /**
+     * Gets the CSS class name for the current theme
+     */
+    getThemeClass() {
+        const baseTheme = this.customPalette?.baseTheme || this.getBaseThemeName();
+        switch (baseTheme) {
+            case 'light':
+                return CSS_CLASSES.THEME_LIGHT;
+            case 'dark':
+                return CSS_CLASSES.THEME_DARK;
+            case 'terminal':
+                return CSS_CLASSES.THEME_TERMINAL;
+            case 'neon':
+                return CSS_CLASSES.THEME_NEON;
+            case 'minimal':
+                return CSS_CLASSES.THEME_MINIMAL;
+            default:
+                return CSS_CLASSES.THEME_LIGHT;
+        }
+    }
+    /**
+     * Gets the font family for the current theme
+     */
+    getFontFamily() {
+        return this.currentTheme.fonts?.primary || 'system-ui, sans-serif';
+    }
+    /**
+     * Gets the monospace font family for the current theme
+     */
+    getMonospaceFontFamily() {
+        return this.currentTheme.fonts?.monospace || 'monospace';
+    }
+    /**
+     * Gets a spacing value for the current theme
+     */
+    getSpacing(size) {
+        return this.currentTheme.spacing?.[size] || '8px';
+    }
+    /**
+     * Gets a border radius value for the current theme
+     */
+    getBorderRadius(size) {
+        return this.currentTheme.borderRadius?.[size] || '4px';
+    }
+    /**
+     * Gets a shadow value for the current theme
+     */
+    getShadow(size) {
+        return this.currentTheme.shadows?.[size] || 'none';
+    }
+    /**
+     * Generates CSS custom properties for the current theme
+     */
+    getCSSCustomProperties() {
+        const theme = this.getComputedTheme();
+        const properties = {};
+        // Color properties
+        Object.entries(theme.palette).forEach(([key, value]) => {
+            properties[`--aomi-color-${key}`] = value;
+        });
+        // Font properties
+        if (theme.fonts?.primary) {
+            properties['--aomi-font-primary'] = theme.fonts.primary;
+        }
+        if (theme.fonts?.monospace) {
+            properties['--aomi-font-monospace'] = theme.fonts.monospace;
+        }
+        // Spacing properties
+        if (theme.spacing) {
+            Object.entries(theme.spacing).forEach(([key, value]) => {
+                properties[`--aomi-spacing-${key}`] = value;
+            });
+        }
+        // Border radius properties
+        if (theme.borderRadius) {
+            Object.entries(theme.borderRadius).forEach(([key, value]) => {
+                properties[`--aomi-radius-${key}`] = value;
+            });
+        }
+        // Shadow properties
+        if (theme.shadows) {
+            Object.entries(theme.shadows).forEach(([key, value]) => {
+                properties[`--aomi-shadow-${key}`] = value;
+            });
+        }
+        return properties;
+    }
+    /**
+     * Applies the theme to a DOM element
+     */
+    applyThemeToElement(element) {
+        const properties = this.getCSSCustomProperties();
+        Object.entries(properties).forEach(([property, value]) => {
+            element.style.setProperty(property, value);
+        });
+        // Add theme class
+        element.classList.add(this.getThemeClass());
+    }
+    /**
+     * Generates CSS string for the current theme
+     */
+    generateCSS(selector = '.aomi-chat-widget') {
+        const properties = this.getCSSCustomProperties();
+        const cssRules = [];
+        // Main theme CSS
+        const mainRule = Object.entries(properties)
+            .map(([property, value]) => `  ${property}: ${value};`)
+            .join('\n');
+        cssRules.push(`${selector} {\n${mainRule}\n}`);
+        // Add component-specific styles
+        cssRules.push(this.generateComponentCSS(selector));
+        return cssRules.join('\n\n');
+    }
+    /**
+     * Destroys the theme manager
+     */
+    destroy() {
+        // Clean up any resources if needed
+    }
+    /*
+     * ============================================================================
+     * PRIVATE METHODS
+     * ============================================================================
+     */
+    resolveTheme(theme) {
+        if (!theme) {
+            return PREDEFINED_THEMES.light;
+        }
+        if (typeof theme === 'string') {
+            const predefinedTheme = PREDEFINED_THEMES[theme];
+            if (!predefinedTheme) {
+                throw createConfigurationError(`Unknown theme: ${theme}`);
+            }
+            return predefinedTheme;
+        }
+        if (this.isCustomPalette(theme)) {
+            const baseTheme = PREDEFINED_THEMES[theme.baseTheme];
+            if (!baseTheme) {
+                throw createConfigurationError(`Unknown base theme: ${theme.baseTheme}`);
+            }
+            return {
+                ...baseTheme,
+                palette: {
+                    primary: theme.primary,
+                    background: theme.background,
+                    surface: theme.surface,
+                    text: theme.text,
+                    textSecondary: theme.textSecondary,
+                    border: theme.border,
+                    success: theme.success,
+                    error: theme.error,
+                    warning: theme.warning,
+                    accent: theme.accent,
+                },
+            };
+        }
+        throw createConfigurationError('Invalid theme configuration');
+    }
+    isCustomPalette(theme) {
+        if (typeof theme !== 'object' || theme === null)
+            return false;
+        const palette = theme;
+        return (typeof palette.baseTheme === 'string' &&
+            typeof palette.primary === 'string' &&
+            typeof palette.background === 'string' &&
+            typeof palette.surface === 'string' &&
+            typeof palette.text === 'string' &&
+            typeof palette.textSecondary === 'string' &&
+            typeof palette.border === 'string' &&
+            typeof palette.success === 'string' &&
+            typeof palette.error === 'string' &&
+            typeof palette.warning === 'string' &&
+            typeof palette.accent === 'string');
+    }
+    getBaseThemeName() {
+        // Find the base theme name by comparing palettes
+        for (const [themeName, themeDefinition] of Object.entries(PREDEFINED_THEMES)) {
+            if (this.isPaletteEqual(themeDefinition.palette, this.currentTheme.palette)) {
+                return themeName;
+            }
+        }
+        return 'light'; // fallback
+    }
+    isPaletteEqual(palette1, palette2) {
+        const keys = Object.keys(palette1);
+        return keys.every(key => palette1[key] === palette2[key]);
+    }
+    generateComponentCSS(selector) {
+        return `
+/* Chat Interface */
+${selector} .${CSS_CLASSES.CHAT_INTERFACE} {
+  background-color: var(--aomi-color-background);
+  color: var(--aomi-color-text);
+  border: 1px solid var(--aomi-color-border);
+  border-radius: var(--aomi-radius-md);
+  font-family: var(--aomi-font-primary);
+}
+
+/* Message List */
+${selector} .${CSS_CLASSES.MESSAGE_LIST} {
+  padding: var(--aomi-spacing-md);
+  overflow-y: auto;
+}
+
+/* Message Input */
+${selector} .${CSS_CLASSES.MESSAGE_INPUT} {
+  background-color: var(--aomi-color-surface);
+  border: 1px solid var(--aomi-color-border);
+  border-radius: var(--aomi-radius-sm);
+  color: var(--aomi-color-text);
+  padding: var(--aomi-spacing-sm);
+  font-family: var(--aomi-font-primary);
+}
+
+${selector} .${CSS_CLASSES.MESSAGE_INPUT}:focus {
+  outline: none;
+  border-color: var(--aomi-color-primary);
+  box-shadow: 0 0 0 2px var(--aomi-color-primary)25;
+}
+
+/* Wallet Status */
+${selector} .${CSS_CLASSES.WALLET_STATUS} {
+  background-color: var(--aomi-color-surface);
+  color: var(--aomi-color-textSecondary);
+  padding: var(--aomi-spacing-sm);
+  border-radius: var(--aomi-radius-sm);
+  font-size: 12px;
+}
+
+${selector} .${CSS_CLASSES.WALLET_STATUS}.${CSS_CLASSES.CONNECTED} {
+  color: var(--aomi-color-success);
+}
+
+${selector} .${CSS_CLASSES.WALLET_STATUS}.${CSS_CLASSES.DISCONNECTED} {
+  color: var(--aomi-color-error);
+}
+
+/* Typing Indicator */
+${selector} .${CSS_CLASSES.TYPING_INDICATOR} {
+  color: var(--aomi-color-textSecondary);
+  font-style: italic;
+  padding: var(--aomi-spacing-sm);
+}
+
+/* State Classes */
+${selector}.${CSS_CLASSES.LOADING} {
+  opacity: 0.7;
+  pointer-events: none;
+}
+
+${selector}.${CSS_CLASSES.ERROR} {
+  border-color: var(--aomi-color-error);
+}
+
+${selector}.${CSS_CLASSES.DISABLED} {
+  opacity: 0.5;
+  pointer-events: none;
+}
+
+/* Terminal Theme Specific */
+${selector}.${CSS_CLASSES.THEME_TERMINAL} {
+  font-family: var(--aomi-font-monospace);
+  background-color: var(--aomi-color-background);
+}
+
+${selector}.${CSS_CLASSES.THEME_TERMINAL} .${CSS_CLASSES.CHAT_INTERFACE} {
+  border: 1px solid var(--aomi-color-primary);
+  box-shadow: var(--aomi-shadow-md);
+}
+
+/* Neon Theme Specific */
+${selector}.${CSS_CLASSES.THEME_NEON} {
+  background: linear-gradient(135deg, var(--aomi-color-background), var(--aomi-color-surface));
+}
+
+${selector}.${CSS_CLASSES.THEME_NEON} .${CSS_CLASSES.CHAT_INTERFACE} {
+  border: 1px solid var(--aomi-color-primary);
+  box-shadow: 0 0 20px var(--aomi-color-primary)50;
+}`;
+    }
+}
+/*
+ * ============================================================================
+ * UTILITY FUNCTIONS
+ * ============================================================================
+ */
+/**
+ * Creates a theme manager instance
+ */
+function createThemeManager(theme) {
+    return new ThemeManager(theme);
+}
+/**
+ * Gets all available predefined themes
+ */
+function getAvailableThemes() {
+    return { ...PREDEFINED_THEMES };
+}
+/**
+ * Validates a custom palette
+ */
+function validateCustomPalette(palette) {
+    if (typeof palette !== 'object' || palette === null)
+        return false;
+    const p = palette;
+    const requiredKeys = [
+        'baseTheme', 'primary', 'background', 'surface', 'text', 'textSecondary',
+        'border', 'success', 'error', 'warning', 'accent',
+    ];
+    return requiredKeys.every(key => typeof p[key] === 'string');
+}
+/**
+ * Creates a custom palette from a base theme
+ */
+function createCustomPalette(baseTheme, overrides) {
+    const basePalette = THEME_PALETTES[baseTheme];
+    if (!basePalette) {
+        throw createConfigurationError(`Unknown base theme: ${baseTheme}`);
+    }
+    return {
+        baseTheme,
+        ...basePalette,
+        ...overrides,
+    };
+}
+
+// WalletManager - Handles wallet connection and transactions
+/*
+ * ============================================================================
+ * WALLET MANAGER CLASS
+ * ============================================================================
+ */
+class WalletManager extends EventEmitter {
+    constructor(provider) {
+        super();
+        this.currentAccount = null;
+        this.currentChainId = null;
+        this.isConnected = false;
+        this.provider = provider;
+        this.setupEventListeners();
+        this.initializeState();
+    }
+    /*
+     * ============================================================================
+     * PUBLIC API
+     * ============================================================================
+     */
+    /**
+     * Gets the current connected account
+     */
+    getCurrentAccount() {
+        return this.currentAccount;
+    }
+    /**
+     * Gets the current chain ID
+     */
+    getCurrentChainId() {
+        return this.currentChainId;
+    }
+    /**
+     * Gets the current network name
+     */
+    getCurrentNetworkName() {
+        if (!this.currentChainId)
+            return null;
+        return SUPPORTED_CHAINS[this.currentChainId] || 'Unknown Network';
+    }
+    /**
+     * Checks if wallet is connected
+     */
+    getIsConnected() {
+        return this.isConnected;
+    }
+    /**
+     * Connects to the wallet
+     */
+    async connect() {
+        try {
+            const accounts = await this.provider.request({
+                id: Date.now(),
+                method: 'eth_requestAccounts',
+                params: [],
+            });
+            if (!accounts || accounts.length === 0) {
+                throw createWalletError(ERROR_CODES.WALLET_CONNECTION_FAILED, 'No accounts returned from wallet');
+            }
+            const account = accounts[0];
+            if (!isEthereumAddress(account)) {
+                throw createWalletError(ERROR_CODES.WALLET_CONNECTION_FAILED, 'Invalid account address');
+            }
+            this.currentAccount = account;
+            this.isConnected = true;
+            // Get chain ID
+            await this.updateChainId();
+            this.emit('connect', account);
+            return account;
+        }
+        catch (error) {
+            const walletError = error instanceof Error
+                ? createWalletError(ERROR_CODES.WALLET_CONNECTION_FAILED, error.message)
+                : createWalletError(ERROR_CODES.WALLET_CONNECTION_FAILED, 'Unknown error');
+            this.emit('error', walletError);
+            throw walletError;
+        }
+    }
+    /**
+     * Disconnects from the wallet
+     */
+    disconnect() {
+        this.currentAccount = null;
+        this.currentChainId = null;
+        this.isConnected = false;
+        this.emit('disconnect');
+    }
+    /**
+     * Switches to a specific network
+     */
+    async switchNetwork(chainId) {
+        try {
+            await this.provider.request({
+                id: Date.now(),
+                method: 'wallet_switchEthereumChain',
+                params: [{ chainId: `0x${chainId.toString(16)}` }],
+            });
+        }
+        catch (error) {
+            // If the chain is not added, try to add it
+            if (error.code === 4902) {
+                await this.addNetwork(chainId);
+            }
+            else {
+                throw createWalletError(ERROR_CODES.UNSUPPORTED_NETWORK, `Failed to switch to network ${chainId}: ${error.message}`);
+            }
+        }
+    }
+    /**
+     * Sends a transaction
+     */
+    async sendTransaction(transaction) {
+        if (!this.isConnected || !this.currentAccount) {
+            throw createWalletError(ERROR_CODES.WALLET_NOT_CONNECTED, 'Wallet is not connected');
+        }
+        try {
+            // Validate transaction
+            this.validateTransaction(transaction);
+            // Prepare transaction parameters
+            const txParams = {
+                from: this.currentAccount,
+                to: transaction.to,
+                value: transaction.value,
+                data: transaction.data,
+            };
+            if (transaction.gas) {
+                txParams.gas = transaction.gas;
+            }
+            // Send transaction
+            const txHash = await this.provider.request({
+                id: Date.now(),
+                method: 'eth_sendTransaction',
+                params: [txParams],
+            });
+            if (!isTransactionHash(txHash)) {
+                throw createTransactionError('Invalid transaction hash returned');
+            }
+            return txHash;
+        }
+        catch (error) {
+            // Handle user rejection
+            if (error.code === 4001) {
+                throw createWalletError(ERROR_CODES.TRANSACTION_REJECTED, 'Transaction was rejected by user');
+            }
+            const message = error.message || 'Transaction failed';
+            throw createTransactionError(message);
+        }
+    }
+    /**
+     * Signs a message
+     */
+    async signMessage(message) {
+        if (!this.isConnected || !this.currentAccount) {
+            throw createWalletError(ERROR_CODES.WALLET_NOT_CONNECTED, 'Wallet is not connected');
+        }
+        try {
+            const signature = await this.provider.request({
+                id: Date.now(),
+                method: 'personal_sign',
+                params: [message, this.currentAccount],
+            });
+            return signature;
+        }
+        catch (error) {
+            if (error.code === 4001) {
+                throw createWalletError(ERROR_CODES.TRANSACTION_REJECTED, 'Message signing was rejected by user');
+            }
+            throw createWalletError(ERROR_CODES.UNKNOWN_ERROR, `Failed to sign message: ${error.message}`);
+        }
+    }
+    /**
+     * Gets account balance
+     */
+    async getBalance(address) {
+        const accountAddress = address || this.currentAccount;
+        if (!accountAddress) {
+            throw createWalletError(ERROR_CODES.WALLET_NOT_CONNECTED, 'No account available');
+        }
+        try {
+            const balance = await this.provider.request({
+                id: Date.now(),
+                method: 'eth_getBalance',
+                params: [accountAddress, 'latest'],
+            });
+            return balance;
+        }
+        catch (error) {
+            throw createWalletError(ERROR_CODES.UNKNOWN_ERROR, `Failed to get balance: ${error.message}`);
+        }
+    }
+    /**
+     * Updates the provider
+     */
+    updateProvider(provider) {
+        // Clean up old provider
+        this.removeProviderListeners();
+        // Set new provider
+        this.provider = provider;
+        // Setup new listeners
+        this.setupEventListeners();
+        // Re-initialize state
+        this.initializeState();
+    }
+    /**
+     * Destroys the wallet manager
+     */
+    destroy() {
+        this.removeProviderListeners();
+        this.disconnect();
+        this.removeAllListeners();
+    }
+    /*
+     * ============================================================================
+     * PRIVATE METHODS
+     * ============================================================================
+     */
+    async initializeState() {
+        try {
+            // Check if already connected
+            const accounts = await this.provider.request({
+                id: Date.now(),
+                method: 'eth_accounts',
+                params: [],
+            });
+            if (accounts && accounts.length > 0 && isEthereumAddress(accounts[0])) {
+                this.currentAccount = accounts[0];
+                this.isConnected = true;
+                await this.updateChainId();
+                this.emit('connect', accounts[0]);
+            }
+        }
+        catch (error) {
+            // Ignore errors during initialization
+            console.warn('Failed to initialize wallet state:', error);
+        }
+    }
+    async updateChainId() {
+        try {
+            const chainId = await this.provider.request({
+                id: Date.now(),
+                method: 'eth_chainId',
+                params: [],
+            });
+            const numericChainId = parseInt(chainId, 16);
+            if (this.currentChainId !== numericChainId) {
+                this.currentChainId = numericChainId;
+                this.emit('chainChange', numericChainId);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to get chain ID:', error);
+        }
+    }
+    setupEventListeners() {
+        if (this.provider.on) {
+            this.provider.on('accountsChanged', this.handleAccountsChanged.bind(this));
+            this.provider.on('chainChanged', this.handleChainChanged.bind(this));
+            this.provider.on('disconnect', this.handleDisconnect.bind(this));
+        }
+    }
+    removeProviderListeners() {
+        if (this.provider.removeListener) {
+            this.provider.removeListener?.('accountsChanged', this.handleAccountsChanged.bind(this));
+            this.provider.removeListener?.('chainChanged', this.handleChainChanged.bind(this));
+            this.provider.removeListener('disconnect', this.handleDisconnect.bind(this));
+        }
+    }
+    handleAccountsChanged(accounts) {
+        if (!accounts || accounts.length === 0) {
+            this.disconnect();
+        }
+        else if (accounts[0] !== this.currentAccount) {
+            this.currentAccount = accounts[0];
+            this.isConnected = true;
+            this.emit('accountsChange', accounts);
+            this.emit('connect', accounts[0]);
+        }
+    }
+    handleChainChanged(chainId) {
+        const numericChainId = parseInt(chainId, 16);
+        this.currentChainId = numericChainId;
+        this.emit('chainChange', numericChainId);
+    }
+    handleDisconnect() {
+        this.disconnect();
+    }
+    validateTransaction(transaction) {
+        if (!isEthereumAddress(transaction.to)) {
+            throw createTransactionError('Invalid recipient address');
+        }
+        // Validate value (should be hex string)
+        if (!/^0x[0-9a-fA-F]*$/.test(transaction.value)) {
+            throw createTransactionError('Invalid transaction value');
+        }
+        // Validate data (should be hex string)
+        if (transaction.data && !/^0x[0-9a-fA-F]*$/.test(transaction.data)) {
+            throw createTransactionError('Invalid transaction data');
+        }
+        // Validate gas (should be hex string if provided)
+        if (transaction.gas && !/^0x[0-9a-fA-F]*$/.test(transaction.gas)) {
+            throw createTransactionError('Invalid gas value');
+        }
+    }
+    async addNetwork(chainId) {
+        const networkConfig = this.getNetworkConfig(chainId);
+        if (!networkConfig) {
+            throw createWalletError(ERROR_CODES.UNSUPPORTED_NETWORK, `Network ${chainId} is not supported`);
+        }
+        try {
+            await this.provider.request({
+                id: Date.now(),
+                method: 'wallet_addEthereumChain',
+                params: [networkConfig],
+            });
+        }
+        catch (error) {
+            throw createWalletError(ERROR_CODES.UNSUPPORTED_NETWORK, `Failed to add network ${chainId}: ${error.message}`);
+        }
+    }
+    getNetworkConfig(chainId) {
+        const configs = {
+            1: null, // Mainnet is built-in
+            5: null, // Goerli is built-in
+            10: {
+                chainId: '0xa',
+                chainName: 'Optimism',
+                nativeCurrency: {
+                    name: 'Ether',
+                    symbol: 'ETH',
+                    decimals: 18,
+                },
+                rpcUrls: ['https://mainnet.optimism.io'],
+                blockExplorerUrls: ['https://optimistic.etherscan.io'],
+            },
+            11155111: null, // Sepolia is built-in
+            100: {
+                chainId: '0x64',
+                chainName: 'Gnosis',
+                nativeCurrency: {
+                    name: 'xDai',
+                    symbol: 'XDAI',
+                    decimals: 18,
+                },
+                rpcUrls: ['https://rpc.gnosischain.com'],
+                blockExplorerUrls: ['https://gnosisscan.io'],
+            },
+            1337: null, // Local development
+            31337: null, // Anvil/Hardhat
+            137: {
+                chainId: '0x89',
+                chainName: 'Polygon',
+                nativeCurrency: {
+                    name: 'MATIC',
+                    symbol: 'MATIC',
+                    decimals: 18,
+                },
+                rpcUrls: ['https://polygon-rpc.com'],
+                blockExplorerUrls: ['https://polygonscan.com'],
+            },
+            42161: {
+                chainId: '0xa4b1',
+                chainName: 'Arbitrum One',
+                nativeCurrency: {
+                    name: 'Ether',
+                    symbol: 'ETH',
+                    decimals: 18,
+                },
+                rpcUrls: ['https://arb1.arbitrum.io/rpc'],
+                blockExplorerUrls: ['https://arbiscan.io'],
+            },
+            8453: {
+                chainId: '0x2105',
+                chainName: 'Base',
+                nativeCurrency: {
+                    name: 'Ether',
+                    symbol: 'ETH',
+                    decimals: 18,
+                },
+                rpcUrls: ['https://mainnet.base.org'],
+                blockExplorerUrls: ['https://basescan.org'],
+            },
+            59140: {
+                chainId: '0xe704',
+                chainName: 'Linea Sepolia',
+                nativeCurrency: {
+                    name: 'Linea Ether',
+                    symbol: 'ETH',
+                    decimals: 18,
+                },
+                rpcUrls: ['https://rpc-sepolia.linea.build'],
+                blockExplorerUrls: ['https://sepolia.lineascan.build'],
+            },
+            59144: {
+                chainId: '0xe708',
+                chainName: 'Linea',
+                nativeCurrency: {
+                    name: 'Linea Ether',
+                    symbol: 'ETH',
+                    decimals: 18,
+                },
+                rpcUrls: ['https://rpc.linea.build'],
+                blockExplorerUrls: ['https://lineascan.build'],
+            },
+        };
+        return configs[chainId];
+    }
+}
+/*
+ * ============================================================================
+ * UTILITY FUNCTIONS
+ * ============================================================================
+ */
+/**
+ * Creates a wallet manager instance
+ */
+function createWalletManager(provider) {
+    return new WalletManager(provider);
+}
+/**
+ * Checks if a provider supports the required methods
+ */
+function isValidProvider(provider) {
+    if (!provider || typeof provider !== 'object')
+        return false;
+    const p = provider;
+    return (typeof p.request === 'function' &&
+        typeof p.on === 'function');
+}
+/**
+ * Detects available wallets
+ */
+function detectWallets() {
+    if (typeof window === 'undefined')
+        return [];
+    const wallets = [];
+    // MetaMask
+    if (window.ethereum?.isMetaMask) {
+        wallets.push({
+            name: 'MetaMask',
+            provider: window.ethereum,
+        });
+    }
+    // WalletConnect
+    if (window.ethereum?.isWalletConnect) {
+        wallets.push({
+            name: 'WalletConnect',
+            provider: window.ethereum,
+        });
+    }
+    // Generic ethereum provider
+    if (window.ethereum && !window.ethereum.isMetaMask && !window.ethereum.isWalletConnect) {
+        wallets.push({
+            name: 'Injected Wallet',
+            provider: window.ethereum,
+        });
+    }
+    return wallets;
+}
+
+// AomiChatWidget - Main widget factory and management class
+/*
+ * ============================================================================
+ * WIDGET HANDLER IMPLEMENTATION
+ * ============================================================================
+ */
+class AomiChatWidgetHandlerImpl {
+    constructor(container, config) {
+        this.walletManager = null;
+        this.widgetElement = null;
+        this.isDestroyed = false;
+        this.hasPromptedNetworkSwitch = false;
+        this.eventEmitter = new EventEmitter();
+        this.container = container;
+        this.config = config;
+        // Initialize managers
+        this.chatManager = new ChatManager({
+            backendUrl: config.params.baseUrl || 'http://localhost:8080',
+            sessionId: config.params.sessionId || generateSessionId(),
+            maxMessageLength: 2000,
+            reconnectAttempts: 5,
+            reconnectDelay: 3000,
+        });
+        this.themeManager = new ThemeManager(config.params.theme);
+        // Initialize wallet manager if provider is available
+        if (config.provider) {
+            this.walletManager = new WalletManager(config.provider);
+        }
+        this.setupEventListeners();
+        this.render();
+        this.initialize();
+    }
+    /*
+     * ============================================================================
+     * PUBLIC API METHODS
+     * ============================================================================
+     */
+    async sendMessage(message) {
+        if (this.isDestroyed) {
+            throw new AomiChatError(ERROR_CODES.INITIALIZATION_FAILED, 'Widget has been destroyed');
+        }
+        return this.chatManager.sendMessage(message);
+    }
+    updateParams(params) {
+        if (this.isDestroyed) {
+            throw new AomiChatError(ERROR_CODES.INITIALIZATION_FAILED, 'Widget has been destroyed');
+        }
+        // Validate new parameters
+        const previousParams = this.config.params;
+        const mergedParams = { ...previousParams, ...params };
+        const errors = validateWidgetParams(mergedParams);
+        if (errors.length > 0) {
+            throw createConfigurationError(`Invalid parameters: ${errors.join(', ')}`);
+        }
+        // Update configuration
+        this.config.params = mergedParams;
+        if (params.chainId && params.chainId !== previousParams.chainId) {
+            this.hasPromptedNetworkSwitch = false;
+        }
+        // Update theme if changed
+        if (params.theme) {
+            this.themeManager.updateTheme(params.theme);
+            this.applyTheme();
+        }
+        // Update dimensions if changed
+        if (params.width || params.height) {
+            this.updateDimensions();
+        }
+        // Re-render if necessary
+        this.render();
+    }
+    updateProvider(provider) {
+        if (this.isDestroyed) {
+            throw new AomiChatError(ERROR_CODES.INITIALIZATION_FAILED, 'Widget has been destroyed');
+        }
+        this.config.provider = provider;
+        this.hasPromptedNetworkSwitch = false;
+        if (provider) {
+            if (this.walletManager) {
+                this.walletManager.updateProvider(provider);
+            }
+            else {
+                this.walletManager = new WalletManager(provider);
+                this.setupWalletEventListeners();
+            }
+        }
+        else {
+            if (this.walletManager) {
+                this.walletManager.destroy();
+                this.walletManager = null;
+            }
+        }
+    }
+    getState() {
+        return this.chatManager.getState();
+    }
+    getSessionId() {
+        return this.chatManager.getSessionId();
+    }
+    isReady() {
+        const state = this.getState();
+        return state.connectionStatus === ConnectionStatus.CONNECTED;
+    }
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+        return this;
+    }
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+        return this;
+    }
+    clearChat() {
+        if (this.isDestroyed)
+            return;
+        this.chatManager.clearMessages();
+    }
+    exportChat() {
+        return this.getState().messages;
+    }
+    resize(width, height) {
+        if (this.isDestroyed)
+            return;
+        if (width)
+            this.config.params.width = width;
+        if (height)
+            this.config.params.height = height;
+        this.updateDimensions();
+        this.eventEmitter.emit(WIDGET_EVENTS.RESIZE, {
+            width: parseInt(width || this.config.params.width || '0'),
+            height: parseInt(height || this.config.params.height || '0'),
+        });
+    }
+    focus() {
+        if (this.isDestroyed || !this.widgetElement)
+            return;
+        const input = this.widgetElement.querySelector('input, textarea');
+        if (input) {
+            input.focus();
+        }
+    }
+    destroy() {
+        if (this.isDestroyed)
+            return;
+        this.isDestroyed = true;
+        // Clean up managers
+        this.chatManager.destroy();
+        this.themeManager.destroy();
+        if (this.walletManager) {
+            this.walletManager.destroy();
+        }
+        // Remove widget from DOM
+        if (this.widgetElement && this.widgetElement.parentNode) {
+            this.widgetElement.parentNode.removeChild(this.widgetElement);
+        }
+        // Clear container
+        this.container.innerHTML = '';
+        // Remove all event listeners
+        this.eventEmitter.removeAllListeners();
+        this.eventEmitter.emit(WIDGET_EVENTS.DESTROY);
+    }
+    /*
+     * ============================================================================
+     * PRIVATE METHODS
+     * ============================================================================
+     */
+    async initialize() {
+        try {
+            // Connect to backend
+            await this.chatManager.connectSSE();
+            // Send welcome message if configured
+            if (this.config.params.welcomeMessage) {
+                await this.chatManager.sendSystemMessage(this.config.params.welcomeMessage);
+            }
+            this.eventEmitter.emit(WIDGET_EVENTS.READY);
+        }
+        catch (error) {
+            const chatError = error instanceof AomiChatError
+                ? error
+                : createConnectionError('Failed to initialize widget');
+            this.eventEmitter.emit(WIDGET_EVENTS.ERROR, chatError);
+        }
+    }
+    setupEventListeners() {
+        // Chat manager events
+        this.chatManager.on('stateChange', (state) => {
+            // Forward state changes to widget listeners
+            this.forwardStateEvents(state);
+        });
+        this.chatManager.on('message', (message) => {
+            this.eventEmitter.emit(WIDGET_EVENTS.MESSAGE, message);
+        });
+        this.chatManager.on('error', (error) => {
+            this.eventEmitter.emit(WIDGET_EVENTS.ERROR, error);
+        });
+        this.chatManager.on('connectionChange', (status) => {
+            this.eventEmitter.emit(WIDGET_EVENTS.CONNECTION_CHANGE, status);
+        });
+        this.chatManager.on('transactionRequest', (transaction) => {
+            this.eventEmitter.emit(WIDGET_EVENTS.TRANSACTION_REQUEST, transaction);
+            this.handleTransactionRequest(transaction);
+        });
+        // Set up wallet event listeners if wallet manager exists
+        if (this.walletManager) {
+            this.setupWalletEventListeners();
+        }
+    }
+    setupWalletEventListeners() {
+        if (!this.walletManager)
+            return;
+        this.walletManager.on('connect', (address) => {
+            const chainId = this.walletManager?.getCurrentChainId() ?? null;
+            const networkName = this.getNetworkName(chainId);
+            this.chatManager.updateWalletState({
+                isConnected: true,
+                address,
+                chainId: chainId ?? undefined,
+                networkName,
+            });
+            this.eventEmitter.emit(WIDGET_EVENTS.WALLET_CONNECT, address);
+            const chainLabel = chainId ?? 'unknown';
+            const connectMessage = `User connected wallet with address ${address} on ${networkName} network ` +
+                `(Chain ID: ${chainLabel}). Ready to help with transactions.`;
+            void this.safeSendSystemMessage(connectMessage);
+            void this.maybePromptNetworkSwitch();
+        });
+        this.walletManager.on('disconnect', () => {
+            this.chatManager.updateWalletState({
+                isConnected: false,
+                address: undefined,
+                chainId: undefined,
+                networkName: undefined,
+            });
+            this.hasPromptedNetworkSwitch = false;
+            this.eventEmitter.emit(WIDGET_EVENTS.WALLET_DISCONNECT);
+            void this.safeSendSystemMessage('Wallet disconnected. Confirm to switch to testnet');
+        });
+        this.walletManager.on('chainChange', (chainId) => {
+            const networkName = this.getNetworkName(chainId);
+            this.chatManager.updateWalletState({ chainId, networkName });
+            this.hasPromptedNetworkSwitch = false;
+            this.eventEmitter.emit(WIDGET_EVENTS.NETWORK_CHANGE, chainId);
+            void this.safeSendSystemMessage(`User switched wallet to ${networkName} network (Chain ID: ${chainId}).`);
+            void this.maybePromptNetworkSwitch();
+        });
+        this.walletManager.on('error', (error) => {
+            this.eventEmitter.emit(WIDGET_EVENTS.ERROR, error);
+        });
+    }
+    forwardStateEvents(state) {
+        // Forward typing and processing changes
+        this.eventEmitter.emit(WIDGET_EVENTS.TYPING_CHANGE, state.isTyping);
+        this.eventEmitter.emit(WIDGET_EVENTS.PROCESSING_CHANGE, state.isProcessing);
+    }
+    async handleTransactionRequest(transaction) {
+        if (!this.walletManager) {
+            await this.chatManager.sendTransactionResult(false, undefined, 'No wallet connected');
+            return;
+        }
+        try {
+            const txHash = await this.walletManager.sendTransaction({
+                to: transaction.to,
+                value: transaction.value,
+                data: transaction.data,
+                gas: transaction.gas,
+            });
+            await this.chatManager.sendTransactionResult(true, txHash);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Transaction failed';
+            await this.chatManager.sendTransactionResult(false, undefined, message);
+        }
+    }
+    async safeSendSystemMessage(message) {
+        try {
+            await this.chatManager.sendSystemMessage(message);
+        }
+        catch (error) {
+            this.eventEmitter.emit(WIDGET_EVENTS.ERROR, error);
+        }
+    }
+    async maybePromptNetworkSwitch() {
+        if (!this.walletManager)
+            return;
+        const chainId = this.walletManager.getCurrentChainId();
+        if (!chainId)
+            return;
+        if (this.hasPromptedNetworkSwitch)
+            return;
+        const walletNetwork = this.getNetworkName(chainId);
+        const backendNetwork = this.getNetworkName(this.config.params.chainId ?? DEFAULT_CHAIN_ID);
+        if (walletNetwork === backendNetwork)
+            return;
+        this.hasPromptedNetworkSwitch = true;
+        const promptMessage = `New wallet connection: ${walletNetwork}, System configuration: ${backendNetwork}. ` +
+            'Prompt user to confirm network switch';
+        await this.safeSendSystemMessage(promptMessage);
+    }
+    getNetworkName(chainId) {
+        switch (chainId) {
+            case 1:
+                return 'mainnet';
+            case 5:
+            case 11155111:
+            case 1337:
+            case 31337:
+                return 'testnet';
+            case 10:
+                return 'optimism';
+            case 100:
+                return 'gnosis';
+            case 137:
+                return 'polygon';
+            case 42161:
+                return 'arbitrum';
+            case 8453:
+                return 'base';
+            case 59140:
+                return 'linea-sepolia';
+            case 59144:
+                return 'linea';
+            default:
+                return 'testnet';
+        }
+    }
+    render() {
+        // Clear existing content
+        this.container.innerHTML = '';
+        // Create widget element
+        this.widgetElement = createElement('div', {
+            className: [
+                CSS_CLASSES.WIDGET_ROOT,
+                CSS_CLASSES.WIDGET_CONTAINER,
+                this.themeManager.getThemeClass(),
+                this.getModeClass(),
+            ],
+            styles: {
+                width: this.config.params.width || DEFAULT_WIDGET_WIDTH,
+                height: this.config.params.height || DEFAULT_WIDGET_HEIGHT,
+                position: 'relative',
+                overflow: 'hidden',
+                fontFamily: this.themeManager.getFontFamily(),
+            },
+        });
+        // Apply theme
+        this.applyTheme();
+        // Render chat interface
+        this.renderChatInterface();
+        // Add to container
+        this.container.appendChild(this.widgetElement);
+    }
+    renderChatInterface() {
+        if (!this.widgetElement)
+            return;
+        /*
+         * This would render the actual chat UI
+         * For now, create a placeholder
+         */
+        const chatInterface = createElement('div', {
+            className: CSS_CLASSES.CHAT_INTERFACE,
+            styles: {
+                width: '100%',
+                height: '100%',
+                display: 'flex',
+                flexDirection: 'column',
+                backgroundColor: this.themeManager.getColor('background'),
+                color: this.themeManager.getColor('text'),
+                border: `1px solid ${this.themeManager.getColor('border')}`,
+                borderRadius: '8px',
+            },
+            children: [
+                createElement('div', {
+                    styles: {
+                        padding: '16px',
+                        textAlign: 'center',
+                        fontSize: '14px',
+                        color: this.themeManager.getColor('textSecondary'),
+                    },
+                    children: ['Chat interface will be implemented here'],
+                }),
+            ],
+        });
+        this.widgetElement.appendChild(chatInterface);
+    }
+    applyTheme() {
+        if (!this.widgetElement)
+            return;
+        const theme = this.themeManager.getComputedTheme();
+        // Apply CSS custom properties for theme colors
+        Object.entries(theme.palette).forEach(([key, value]) => {
+            this.widgetElement.style.setProperty(`--aomi-${key}`, value);
+        });
+        // Apply theme class
+        this.widgetElement.className = [
+            CSS_CLASSES.WIDGET_ROOT,
+            CSS_CLASSES.WIDGET_CONTAINER,
+            this.themeManager.getThemeClass(),
+            this.getModeClass(),
+        ].join(' ');
+    }
+    getModeClass() {
+        switch (this.config.params.mode) {
+            case 'minimal':
+                return CSS_CLASSES.MODE_MINIMAL;
+            case 'compact':
+                return CSS_CLASSES.MODE_COMPACT;
+            case 'terminal':
+                return CSS_CLASSES.MODE_TERMINAL;
+            default:
+                return CSS_CLASSES.MODE_FULL;
+        }
+    }
+    updateDimensions() {
+        if (!this.widgetElement)
+            return;
+        this.widgetElement.style.width = this.config.params.width || DEFAULT_WIDGET_WIDTH;
+        this.widgetElement.style.height = this.config.params.height || DEFAULT_WIDGET_HEIGHT;
+    }
+}
+/*
+ * ============================================================================
+ * WIDGET FACTORY FUNCTION
+ * ============================================================================
+ */
+/**
+ * Creates and initializes an Aomi Chat Widget
+ */
+function createAomiChatWidget(container, config) {
+    // Validate environment
+    if (!isBrowser()) {
+        throw createConfigurationError('Widget can only be created in a browser environment');
+    }
+    // Validate container
+    if (!container || !(container instanceof HTMLElement)) {
+        throw createConfigurationError('Container must be a valid HTML element');
+    }
+    // Validate configuration
+    const errors = validateWidgetParams(config.params);
+    if (errors.length > 0) {
+        throw createConfigurationError(`Configuration errors: ${errors.join(', ')}`);
+    }
+    // Create and return widget handler
+    return new AomiChatWidgetHandlerImpl(container, config);
+}
+
+// Main entry point for the Aomi Chat Widget Library
+// Package version (this would be set during build)
+const VERSION = '0.1.0';
+/* eslint-enable no-unused-vars, @typescript-eslint/no-unused-vars */
+// Simple convenience function for basic usage
+function createChatWidget(containerId, options) {
+    // Get container element
+    const container = typeof containerId === 'string'
+        ? document.getElementById(containerId)
+        : containerId;
+    if (!container) {
+        throw createConfigurationError(typeof containerId === 'string'
+            ? `Element with id "${containerId}" not found`
+            : 'Invalid container element');
+    }
+    // Create widget configuration
+    const config = {
+        params: {
+            appCode: options.appCode,
+            theme: options.theme,
+            width: options.width,
+            height: options.height,
+            baseUrl: options.baseUrl,
+        },
+        provider: options.provider,
+        listeners: {
+            onReady: options.onReady,
+            onMessage: options.onMessage,
+            onError: options.onError,
+        },
+    };
+    return createAomiChatWidget(container, config);
+}
+// Default export for convenience
+var index = {
+    createChatWidget,
+    createAomiChatWidget,
+    VERSION,
+    SUPPORTED_CHAINS,
+    PREDEFINED_THEMES,
+    ERROR_CODES,
+    WIDGET_EVENTS,
+};
+
+exports.API_ENDPOINTS = API_ENDPOINTS;
+exports.CSS_CLASSES = CSS_CLASSES;
+exports.ChatError = ChatError;
+exports.ChatManager = ChatManager;
+exports.ConfigurationError = ConfigurationError;
+exports.ConnectionError = ConnectionError;
+exports.DEFAULT_CHAIN_ID = DEFAULT_CHAIN_ID;
+exports.DEFAULT_MAX_HEIGHT = DEFAULT_MAX_HEIGHT;
+exports.DEFAULT_MESSAGE_LENGTH = DEFAULT_MESSAGE_LENGTH;
+exports.DEFAULT_RECONNECT_ATTEMPTS = DEFAULT_RECONNECT_ATTEMPTS;
+exports.DEFAULT_RECONNECT_DELAY = DEFAULT_RECONNECT_DELAY;
+exports.DEFAULT_WIDGET_HEIGHT = DEFAULT_WIDGET_HEIGHT;
+exports.DEFAULT_WIDGET_WIDTH = DEFAULT_WIDGET_WIDTH;
+exports.ERROR_CODES = ERROR_CODES;
+exports.PREDEFINED_THEMES = PREDEFINED_THEMES;
+exports.RateLimitError = RateLimitError;
+exports.SUPPORTED_CHAINS = SUPPORTED_CHAINS;
+exports.SessionError = SessionError;
+exports.THEME_PALETTES = THEME_PALETTES;
+exports.TIMING = TIMING;
+exports.ThemeManager = ThemeManager;
+exports.TransactionError = TransactionError;
+exports.VERSION = VERSION;
+exports.WIDGET_EVENTS = WIDGET_EVENTS;
+exports.WalletError = WalletError;
+exports.WalletManager = WalletManager;
+exports.buildWidgetUrl = buildWidgetUrl;
+exports.createAomiChatWidget = createAomiChatWidget;
+exports.createChatError = createChatError;
+exports.createChatWidget = createChatWidget;
+exports.createConfigurationError = createConfigurationError;
+exports.createConnectionError = createConnectionError;
+exports.createCustomPalette = createCustomPalette;
+exports.createElement = createElement;
+exports.createRateLimitError = createRateLimitError;
+exports.createSessionError = createSessionError;
+exports.createThemeManager = createThemeManager;
+exports.createTransactionError = createTransactionError;
+exports.createWalletError = createWalletError;
+exports.createWalletManager = createWalletManager;
+exports.default = index;
+exports.delay = delay;
+exports.detectWallets = detectWallets;
+exports.formatNumber = formatNumber;
+exports.formatTimestamp = formatTimestamp;
+exports.generateSessionId = generateSessionId;
+exports.getAvailableThemes = getAvailableThemes;
+exports.getViewportDimensions = getViewportDimensions;
+exports.hasProperty = hasProperty;
+exports.isAomiChatError = isAomiChatError;
+exports.isBrowser = isBrowser;
+exports.isChatError = isChatError;
+exports.isConfigurationError = isConfigurationError;
+exports.isConnectionError = isConnectionError;
+exports.isElementVisible = isElementVisible;
+exports.isEthereumAddress = isEthereumAddress;
+exports.isMobile = isMobile;
+exports.isRateLimitError = isRateLimitError;
+exports.isSessionError = isSessionError;
+exports.isTransactionError = isTransactionError;
+exports.isTransactionHash = isTransactionHash;
+exports.isValidProvider = isValidProvider;
+exports.isValidSessionId = isValidSessionId;
+exports.isWalletError = isWalletError;
+exports.parseWidgetParams = parseWidgetParams;
+exports.resolveFlexibleConfig = resolveFlexibleConfig;
+exports.retry = retry;
+exports.truncateAddress = truncateAddress;
+exports.validateCustomPalette = validateCustomPalette;
+exports.validateWidgetParams = validateWidgetParams;
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=index.js.map