@aomi-labs/widget-lib 0.2.0

package/dist/index.umd.js

@@ -0,0 +1,3295 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.AomiWidget = {}));
+})(this, (function (exports) { 'use strict';
+
+	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;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.umd.js.map