@olbrain/js-sdk 1.0.0

package/dist/widget.widget.global.js

@@ -0,0 +1,1747 @@
+"use strict";
+var OlbrainWidget = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // node_modules/eventsource/lib/eventsource.js
+  var require_eventsource = __commonJS({
+    "node_modules/eventsource/lib/eventsource.js"(exports, module) {
+      "use strict";
+      var parse = __require("url").parse;
+      var events = __require("events");
+      var https = __require("https");
+      var http = __require("http");
+      var util = __require("util");
+      var httpsOptions = [
+        "pfx",
+        "key",
+        "passphrase",
+        "cert",
+        "ca",
+        "ciphers",
+        "rejectUnauthorized",
+        "secureProtocol",
+        "servername",
+        "checkServerIdentity"
+      ];
+      var bom = [239, 187, 191];
+      var colon = 58;
+      var space = 32;
+      var lineFeed = 10;
+      var carriageReturn = 13;
+      var maxBufferAheadAllocation = 1024 * 256;
+      var reUnsafeHeader = /^(cookie|authorization)$/i;
+      function hasBom(buf) {
+        return bom.every(function(charCode, index) {
+          return buf[index] === charCode;
+        });
+      }
+      function EventSource2(url, eventSourceInitDict) {
+        var readyState = EventSource2.CONNECTING;
+        var headers = eventSourceInitDict && eventSourceInitDict.headers;
+        var hasNewOrigin = false;
+        Object.defineProperty(this, "readyState", {
+          get: function() {
+            return readyState;
+          }
+        });
+        Object.defineProperty(this, "url", {
+          get: function() {
+            return url;
+          }
+        });
+        var self = this;
+        self.reconnectInterval = 1e3;
+        self.connectionInProgress = false;
+        function onConnectionClosed(message) {
+          if (readyState === EventSource2.CLOSED) return;
+          readyState = EventSource2.CONNECTING;
+          _emit("error", new Event("error", { message }));
+          if (reconnectUrl) {
+            url = reconnectUrl;
+            reconnectUrl = null;
+            hasNewOrigin = false;
+          }
+          setTimeout(function() {
+            if (readyState !== EventSource2.CONNECTING || self.connectionInProgress) {
+              return;
+            }
+            self.connectionInProgress = true;
+            connect();
+          }, self.reconnectInterval);
+        }
+        var req;
+        var lastEventId = "";
+        if (headers && headers["Last-Event-ID"]) {
+          lastEventId = headers["Last-Event-ID"];
+          delete headers["Last-Event-ID"];
+        }
+        var discardTrailingNewline = false;
+        var data = "";
+        var eventName = "";
+        var reconnectUrl = null;
+        function connect() {
+          var options = parse(url);
+          var isSecure = options.protocol === "https:";
+          options.headers = { "Cache-Control": "no-cache", "Accept": "text/event-stream" };
+          if (lastEventId) options.headers["Last-Event-ID"] = lastEventId;
+          if (headers) {
+            var reqHeaders = hasNewOrigin ? removeUnsafeHeaders(headers) : headers;
+            for (var i in reqHeaders) {
+              var header = reqHeaders[i];
+              if (header) {
+                options.headers[i] = header;
+              }
+            }
+          }
+          options.rejectUnauthorized = !(eventSourceInitDict && !eventSourceInitDict.rejectUnauthorized);
+          if (eventSourceInitDict && eventSourceInitDict.createConnection !== void 0) {
+            options.createConnection = eventSourceInitDict.createConnection;
+          }
+          var useProxy = eventSourceInitDict && eventSourceInitDict.proxy;
+          if (useProxy) {
+            var proxy = parse(eventSourceInitDict.proxy);
+            isSecure = proxy.protocol === "https:";
+            options.protocol = isSecure ? "https:" : "http:";
+            options.path = url;
+            options.headers.Host = options.host;
+            options.hostname = proxy.hostname;
+            options.host = proxy.host;
+            options.port = proxy.port;
+          }
+          if (eventSourceInitDict && eventSourceInitDict.https) {
+            for (var optName in eventSourceInitDict.https) {
+              if (httpsOptions.indexOf(optName) === -1) {
+                continue;
+              }
+              var option = eventSourceInitDict.https[optName];
+              if (option !== void 0) {
+                options[optName] = option;
+              }
+            }
+          }
+          if (eventSourceInitDict && eventSourceInitDict.withCredentials !== void 0) {
+            options.withCredentials = eventSourceInitDict.withCredentials;
+          }
+          req = (isSecure ? https : http).request(options, function(res) {
+            self.connectionInProgress = false;
+            if (res.statusCode === 500 || res.statusCode === 502 || res.statusCode === 503 || res.statusCode === 504) {
+              _emit("error", new Event("error", { status: res.statusCode, message: res.statusMessage }));
+              onConnectionClosed();
+              return;
+            }
+            if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307) {
+              var location = res.headers.location;
+              if (!location) {
+                _emit("error", new Event("error", { status: res.statusCode, message: res.statusMessage }));
+                return;
+              }
+              var prevOrigin = new URL(url).origin;
+              var nextOrigin = new URL(location).origin;
+              hasNewOrigin = prevOrigin !== nextOrigin;
+              if (res.statusCode === 307) reconnectUrl = url;
+              url = location;
+              process.nextTick(connect);
+              return;
+            }
+            if (res.statusCode !== 200) {
+              _emit("error", new Event("error", { status: res.statusCode, message: res.statusMessage }));
+              return self.close();
+            }
+            readyState = EventSource2.OPEN;
+            res.on("close", function() {
+              res.removeAllListeners("close");
+              res.removeAllListeners("end");
+              onConnectionClosed();
+            });
+            res.on("end", function() {
+              res.removeAllListeners("close");
+              res.removeAllListeners("end");
+              onConnectionClosed();
+            });
+            _emit("open", new Event("open"));
+            var buf;
+            var newBuffer;
+            var startingPos = 0;
+            var startingFieldLength = -1;
+            var newBufferSize = 0;
+            var bytesUsed = 0;
+            res.on("data", function(chunk) {
+              if (!buf) {
+                buf = chunk;
+                if (hasBom(buf)) {
+                  buf = buf.slice(bom.length);
+                }
+                bytesUsed = buf.length;
+              } else {
+                if (chunk.length > buf.length - bytesUsed) {
+                  newBufferSize = buf.length * 2 + chunk.length;
+                  if (newBufferSize > maxBufferAheadAllocation) {
+                    newBufferSize = buf.length + chunk.length + maxBufferAheadAllocation;
+                  }
+                  newBuffer = Buffer.alloc(newBufferSize);
+                  buf.copy(newBuffer, 0, 0, bytesUsed);
+                  buf = newBuffer;
+                }
+                chunk.copy(buf, bytesUsed);
+                bytesUsed += chunk.length;
+              }
+              var pos = 0;
+              var length = bytesUsed;
+              while (pos < length) {
+                if (discardTrailingNewline) {
+                  if (buf[pos] === lineFeed) {
+                    ++pos;
+                  }
+                  discardTrailingNewline = false;
+                }
+                var lineLength = -1;
+                var fieldLength = startingFieldLength;
+                var c;
+                for (var i2 = startingPos; lineLength < 0 && i2 < length; ++i2) {
+                  c = buf[i2];
+                  if (c === colon) {
+                    if (fieldLength < 0) {
+                      fieldLength = i2 - pos;
+                    }
+                  } else if (c === carriageReturn) {
+                    discardTrailingNewline = true;
+                    lineLength = i2 - pos;
+                  } else if (c === lineFeed) {
+                    lineLength = i2 - pos;
+                  }
+                }
+                if (lineLength < 0) {
+                  startingPos = length - pos;
+                  startingFieldLength = fieldLength;
+                  break;
+                } else {
+                  startingPos = 0;
+                  startingFieldLength = -1;
+                }
+                parseEventStreamLine(buf, pos, fieldLength, lineLength);
+                pos += lineLength + 1;
+              }
+              if (pos === length) {
+                buf = void 0;
+                bytesUsed = 0;
+              } else if (pos > 0) {
+                buf = buf.slice(pos, bytesUsed);
+                bytesUsed = buf.length;
+              }
+            });
+          });
+          req.on("error", function(err) {
+            self.connectionInProgress = false;
+            onConnectionClosed(err.message);
+          });
+          if (req.setNoDelay) req.setNoDelay(true);
+          req.end();
+        }
+        connect();
+        function _emit() {
+          if (self.listeners(arguments[0]).length > 0) {
+            self.emit.apply(self, arguments);
+          }
+        }
+        this._close = function() {
+          if (readyState === EventSource2.CLOSED) return;
+          readyState = EventSource2.CLOSED;
+          if (req.abort) req.abort();
+          if (req.xhr && req.xhr.abort) req.xhr.abort();
+        };
+        function parseEventStreamLine(buf, pos, fieldLength, lineLength) {
+          if (lineLength === 0) {
+            if (data.length > 0) {
+              var type = eventName || "message";
+              _emit(type, new MessageEvent(type, {
+                data: data.slice(0, -1),
+                // remove trailing newline
+                lastEventId,
+                origin: new URL(url).origin
+              }));
+              data = "";
+            }
+            eventName = void 0;
+          } else if (fieldLength > 0) {
+            var noValue = fieldLength < 0;
+            var step = 0;
+            var field = buf.slice(pos, pos + (noValue ? lineLength : fieldLength)).toString();
+            if (noValue) {
+              step = lineLength;
+            } else if (buf[pos + fieldLength + 1] !== space) {
+              step = fieldLength + 1;
+            } else {
+              step = fieldLength + 2;
+            }
+            pos += step;
+            var valueLength = lineLength - step;
+            var value = buf.slice(pos, pos + valueLength).toString();
+            if (field === "data") {
+              data += value + "\n";
+            } else if (field === "event") {
+              eventName = value;
+            } else if (field === "id") {
+              lastEventId = value;
+            } else if (field === "retry") {
+              var retry = parseInt(value, 10);
+              if (!Number.isNaN(retry)) {
+                self.reconnectInterval = retry;
+              }
+            }
+          }
+        }
+      }
+      module.exports = EventSource2;
+      util.inherits(EventSource2, events.EventEmitter);
+      EventSource2.prototype.constructor = EventSource2;
+      ["open", "error", "message"].forEach(function(method) {
+        Object.defineProperty(EventSource2.prototype, "on" + method, {
+          /**
+           * Returns the current listener
+           *
+           * @return {Mixed} the set function or undefined
+           * @api private
+           */
+          get: function get() {
+            var listener = this.listeners(method)[0];
+            return listener ? listener._listener ? listener._listener : listener : void 0;
+          },
+          /**
+           * Start listening for events
+           *
+           * @param {Function} listener the listener
+           * @return {Mixed} the set function or undefined
+           * @api private
+           */
+          set: function set(listener) {
+            this.removeAllListeners(method);
+            this.addEventListener(method, listener);
+          }
+        });
+      });
+      Object.defineProperty(EventSource2, "CONNECTING", { enumerable: true, value: 0 });
+      Object.defineProperty(EventSource2, "OPEN", { enumerable: true, value: 1 });
+      Object.defineProperty(EventSource2, "CLOSED", { enumerable: true, value: 2 });
+      EventSource2.prototype.CONNECTING = 0;
+      EventSource2.prototype.OPEN = 1;
+      EventSource2.prototype.CLOSED = 2;
+      EventSource2.prototype.close = function() {
+        this._close();
+      };
+      EventSource2.prototype.addEventListener = function addEventListener(type, listener) {
+        if (typeof listener === "function") {
+          listener._listener = listener;
+          this.on(type, listener);
+        }
+      };
+      EventSource2.prototype.dispatchEvent = function dispatchEvent(event) {
+        if (!event.type) {
+          throw new Error("UNSPECIFIED_EVENT_TYPE_ERR");
+        }
+        this.emit(event.type, event.detail);
+      };
+      EventSource2.prototype.removeEventListener = function removeEventListener(type, listener) {
+        if (typeof listener === "function") {
+          listener._listener = void 0;
+          this.removeListener(type, listener);
+        }
+      };
+      function Event(type, optionalProperties) {
+        Object.defineProperty(this, "type", { writable: false, value: type, enumerable: true });
+        if (optionalProperties) {
+          for (var f in optionalProperties) {
+            if (optionalProperties.hasOwnProperty(f)) {
+              Object.defineProperty(this, f, { writable: false, value: optionalProperties[f], enumerable: true });
+            }
+          }
+        }
+      }
+      function MessageEvent(type, eventInitDict) {
+        Object.defineProperty(this, "type", { writable: false, value: type, enumerable: true });
+        for (var f in eventInitDict) {
+          if (eventInitDict.hasOwnProperty(f)) {
+            Object.defineProperty(this, f, { writable: false, value: eventInitDict[f], enumerable: true });
+          }
+        }
+      }
+      function removeUnsafeHeaders(headers) {
+        var safe = {};
+        for (var key in headers) {
+          if (reUnsafeHeader.test(key)) {
+            continue;
+          }
+          safe[key] = headers[key];
+        }
+        return safe;
+      }
+    }
+  });
+
+  // src/widget.ts
+  var widget_exports = {};
+  __export(widget_exports, {
+    AgentClient: () => AgentClient,
+    AuthenticationError: () => AuthenticationError,
+    ChatWidget: () => ChatWidget,
+    NetworkError: () => NetworkError,
+    OlbrainError: () => OlbrainError,
+    RateLimitError: () => RateLimitError,
+    SessionNotFoundError: () => SessionNotFoundError,
+    StreamingError: () => StreamingError,
+    VERSION: () => VERSION,
+    ValidationError: () => ValidationError
+  });
+
+  // src/core/exceptions.ts
+  var OlbrainError = class _OlbrainError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "OlbrainError";
+      Object.setPrototypeOf(this, _OlbrainError.prototype);
+    }
+  };
+  var AuthenticationError = class _AuthenticationError extends OlbrainError {
+    constructor(message = "Authentication failed") {
+      super(message);
+      this.name = "AuthenticationError";
+      Object.setPrototypeOf(this, _AuthenticationError.prototype);
+    }
+  };
+  var SessionNotFoundError = class _SessionNotFoundError extends OlbrainError {
+    constructor(sessionId) {
+      super(`Session not found: ${sessionId}`);
+      this.name = "SessionNotFoundError";
+      this.sessionId = sessionId;
+      Object.setPrototypeOf(this, _SessionNotFoundError.prototype);
+    }
+  };
+  var RateLimitError = class _RateLimitError extends OlbrainError {
+    constructor(message = "Rate limit exceeded", retryAfter) {
+      super(message);
+      this.name = "RateLimitError";
+      this.retryAfter = retryAfter;
+      Object.setPrototypeOf(this, _RateLimitError.prototype);
+    }
+  };
+  var NetworkError = class _NetworkError extends OlbrainError {
+    constructor(message = "Network error", statusCode) {
+      super(message);
+      this.name = "NetworkError";
+      this.statusCode = statusCode;
+      Object.setPrototypeOf(this, _NetworkError.prototype);
+    }
+  };
+  var ValidationError = class _ValidationError extends OlbrainError {
+    constructor(message = "Validation error") {
+      super(message);
+      this.name = "ValidationError";
+      Object.setPrototypeOf(this, _ValidationError.prototype);
+    }
+  };
+  var StreamingError = class _StreamingError extends OlbrainError {
+    constructor(message = "Streaming error") {
+      super(message);
+      this.name = "StreamingError";
+      Object.setPrototypeOf(this, _StreamingError.prototype);
+    }
+  };
+
+  // src/core/utils.ts
+  function validateApiKey(apiKey) {
+    if (!apiKey) {
+      throw new ValidationError("API key is required");
+    }
+    const validPrefixes = ["sk_live_", "org_live_", "sk_", "org_"];
+    if (!validPrefixes.some((prefix) => apiKey.startsWith(prefix))) {
+      throw new ValidationError(
+        "Invalid API key format. Must start with sk_, org_, sk_live_, or org_live_"
+      );
+    }
+  }
+  function validateAgentId(agentId) {
+    if (!agentId) {
+      throw new ValidationError("Agent ID is required");
+    }
+  }
+  function formatAuthHeader(apiKey) {
+    return `Bearer ${apiKey}`;
+  }
+  function getExponentialBackoffDelay(attempt, baseDelay = 5e3, maxDelay = 6e4) {
+    const delay2 = baseDelay * Math.pow(2, attempt);
+    return Math.min(delay2, maxDelay);
+  }
+  function isBrowser() {
+    return typeof window !== "undefined" && typeof document !== "undefined";
+  }
+  function isNode() {
+    return typeof process !== "undefined" && process.versions && process.versions.node;
+  }
+  async function getEventSourceImpl() {
+    if (isBrowser()) {
+      return EventSource;
+    }
+    if (isNode()) {
+      try {
+        const { EventSource: NodeEventSource } = await Promise.resolve().then(() => __toESM(require_eventsource()));
+        return NodeEventSource;
+      } catch {
+        throw new Error(
+          'EventSource not available in Node.js. Install "eventsource" package: npm install eventsource'
+        );
+      }
+    }
+    throw new Error("EventSource not available in this environment");
+  }
+
+  // src/core/streaming.ts
+  var MessageStream = class {
+    constructor(config, onMessage, onError) {
+      this.isRunning = false;
+      this.reconnectAttempt = 0;
+      this.config = config;
+      this.onMessage = onMessage;
+      this.onError = onError;
+    }
+    /**
+     * Start the streaming connection
+     */
+    async start() {
+      if (this.isRunning) {
+        return;
+      }
+      this.isRunning = true;
+      this.reconnectAttempt = 0;
+      await this._connect();
+    }
+    /**
+     * Stop the streaming connection
+     */
+    stop() {
+      this.isRunning = false;
+      this._cleanup();
+    }
+    /**
+     * Establish SSE connection
+     */
+    async _connect() {
+      try {
+        const EventSourceImpl = await getEventSourceImpl();
+        const url = `${this.config.baseUrl}/sessions/${this.config.sessionId}/stream`;
+        const headers = {
+          "Authorization": formatAuthHeader(this.config.apiKey),
+          "X-Agent-ID": this.config.agentId
+        };
+        this.eventSource = new EventSourceImpl(url, { headers });
+        this.eventSource.addEventListener("message", (event) => {
+          this._handleMessage(event);
+        });
+        this.eventSource.addEventListener("ping", () => {
+        });
+        this.eventSource.addEventListener("error", () => {
+          this._handleConnectionError();
+        });
+        this.reconnectAttempt = 0;
+      } catch (error) {
+        this._handleConnectionError();
+      }
+    }
+    /**
+     * Handle incoming message event
+     */
+    _handleMessage(event) {
+      if (!event.data) {
+        return;
+      }
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type === "ping" || data.type === "keepalive") {
+          return;
+        }
+        if (data.role && data.content) {
+          const message = {
+            role: data.role,
+            content: data.content,
+            timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+            metadata: data.metadata
+          };
+          this.onMessage(message);
+        }
+      } catch (error) {
+        if (this.onError) {
+          this.onError(
+            new StreamingError(`Failed to parse message: ${error.message}`)
+          );
+        }
+      }
+    }
+    /**
+     * Handle connection errors and attempt reconnection
+     */
+    _handleConnectionError() {
+      if (!this.isRunning) {
+        return;
+      }
+      this._cleanup();
+      const delay2 = getExponentialBackoffDelay(this.reconnectAttempt);
+      if (this.onError) {
+        this.onError(
+          new StreamingError(
+            `Connection lost. Reconnecting in ${delay2}ms (attempt ${this.reconnectAttempt + 1})`
+          )
+        );
+      }
+      this.reconnectAttempt++;
+      this.reconnectTimeout = setTimeout(async () => {
+        if (this.isRunning) {
+          await this._connect();
+        }
+      }, delay2);
+    }
+    /**
+     * Clean up resources
+     */
+    _cleanup() {
+      if (this.eventSource) {
+        this.eventSource.close();
+        this.eventSource = void 0;
+      }
+      if (this.reconnectTimeout) {
+        clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = void 0;
+      }
+    }
+  };
+  var StreamManager = class {
+    constructor() {
+      this.streams = /* @__PURE__ */ new Map();
+    }
+    /**
+     * Start streaming for a session
+     */
+    async startStream(sessionId, config, onMessage, onError) {
+      this.stopStream(sessionId);
+      const stream = new MessageStream(config, onMessage, onError);
+      this.streams.set(sessionId, stream);
+      await stream.start();
+    }
+    /**
+     * Stop streaming for a session
+     */
+    stopStream(sessionId) {
+      const stream = this.streams.get(sessionId);
+      if (stream) {
+        stream.stop();
+        this.streams.delete(sessionId);
+      }
+    }
+    /**
+     * Stop all streams
+     */
+    stopAllStreams() {
+      for (const stream of this.streams.values()) {
+        stream.stop();
+      }
+      this.streams.clear();
+    }
+    /**
+     * Check if a stream is running
+     */
+    isStreamRunning(sessionId) {
+      return this.streams.has(sessionId);
+    }
+  };
+
+  // src/core/client.ts
+  var DEFAULT_BASE_URL = "https://olbrain-agent-cloud-768934887465.us-central1.run.app";
+  var DEFAULT_TIMEOUT_MS = 3e4;
+  var AgentClient = class {
+    constructor(config) {
+      validateApiKey(config.apiKey);
+      validateAgentId(config.agentId);
+      this.config = {
+        agentId: config.agentId,
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl || DEFAULT_BASE_URL
+      };
+      this.streamManager = new StreamManager();
+    }
+    /**
+     * Create a new session
+     */
+    async createSession(options) {
+      const payload = {
+        message: options?.title || "Chat Session",
+        response_mode: "sync",
+        mode: "production"
+      };
+      if (options?.userId) {
+        payload.user_id = options.userId;
+      }
+      if (options?.metadata) {
+        payload.metadata = options.metadata;
+      }
+      const response = await this._request("POST", "/api/agent/webhook", payload);
+      if (!response.session_id) {
+        throw new OlbrainError("Failed to create session: no session_id returned");
+      }
+      return response.session_id;
+    }
+    /**
+     * Get session information
+     * @note May not be implemented on all backends
+     */
+    async getSession(sessionId) {
+      try {
+        const response = await this._request("POST", "/api/agent/webhook", {
+          session_id: sessionId,
+          action: "get_session_info"
+        });
+        return this._parseSessionInfo(response);
+      } catch (error) {
+        console.warn("get_session_info not available, returning basic info");
+        return {
+          sessionId,
+          title: "Session",
+          status: "active",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          messageCount: 0,
+          metadata: {}
+        };
+      }
+    }
+    /**
+     * Update session information
+     * @note May not be implemented on all backends
+     */
+    async updateSession(sessionId, updates) {
+      try {
+        const payload = {
+          session_id: sessionId,
+          action: "update_session"
+        };
+        if (updates.title !== void 0) payload.title = updates.title;
+        if (updates.status !== void 0) payload.status = updates.status;
+        if (updates.metadata !== void 0) payload.metadata = updates.metadata;
+        const response = await this._request("POST", "/api/agent/webhook", payload);
+        return this._parseSessionInfo(response);
+      } catch (error) {
+        console.warn("update_session not available");
+        throw error;
+      }
+    }
+    /**
+     * Delete a session
+     * @note May not be implemented on all backends
+     */
+    async deleteSession(sessionId) {
+      try {
+        await this._request("POST", "/api/agent/webhook", {
+          session_id: sessionId,
+          action: "delete_session"
+        });
+      } catch (error) {
+        console.warn("delete_session not available");
+        throw error;
+      }
+    }
+    /**
+     * Get messages from a session
+     * @note May not be implemented on all backends
+     */
+    async getMessages(sessionId, limit) {
+      try {
+        const response = await this._request("POST", "/api/agent/webhook", {
+          session_id: sessionId,
+          action: "get_messages",
+          limit: limit || 100
+        });
+        return (response.messages || []).map((msg) => ({
+          role: msg.role,
+          content: msg.content,
+          timestamp: msg.timestamp,
+          metadata: msg.metadata
+        }));
+      } catch (error) {
+        console.warn("get_messages not available");
+        return [];
+      }
+    }
+    /**
+     * Get session statistics
+     * @note May not be implemented on all backends
+     */
+    async getSessionStats(sessionId) {
+      try {
+        const response = await this._request("POST", "/api/agent/webhook", {
+          session_id: sessionId,
+          action: "get_stats"
+        });
+        return {
+          sessionId: response.session_id,
+          messageCount: response.message_count,
+          totalTokens: response.total_tokens,
+          createdAt: response.created_at,
+          lastMessageAt: response.last_message_at
+        };
+      } catch (error) {
+        console.warn("get_stats not available");
+        return {
+          sessionId,
+          messageCount: 0,
+          totalTokens: 0,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+    }
+    /**
+     * Send a message and wait for response
+     */
+    async sendAndWait(sessionId, message, options) {
+      if (!message) {
+        throw new ValidationError("Message cannot be empty");
+      }
+      const payload = {
+        session_id: sessionId,
+        message: message.trim(),
+        response_mode: "sync"
+      };
+      if (options?.metadata) {
+        payload.metadata = options.metadata;
+      }
+      const timeout = options?.timeout || DEFAULT_TIMEOUT_MS;
+      const response = await this._request(
+        "POST",
+        "/api/agent/webhook",
+        payload,
+        timeout
+      );
+      return {
+        text: response.response || response.text || "",
+        sessionId: response.session_id,
+        success: response.success !== false,
+        tokenUsage: response.token_usage ? {
+          promptTokens: response.token_usage.prompt_tokens,
+          completionTokens: response.token_usage.completion_tokens,
+          totalTokens: response.token_usage.total_tokens,
+          cost: response.token_usage.cost
+        } : void 0,
+        modelUsed: response.model_used,
+        responseTimeMs: response.response_time_ms,
+        error: response.error
+      };
+    }
+    /**
+     * Send a message (fire and forget)
+     */
+    async send(sessionId, message) {
+      if (!message) {
+        throw new ValidationError("Message cannot be empty");
+      }
+      await this._request("POST", "/api/agent/webhook", {
+        session_id: sessionId,
+        message: message.trim(),
+        response_mode: "sync"
+      });
+    }
+    /**
+     * Start listening for messages via SSE streaming
+     */
+    async listen(sessionId, onMessage, onError) {
+      await this.streamManager.startStream(
+        sessionId,
+        {
+          sessionId,
+          apiKey: this.config.apiKey,
+          agentId: this.config.agentId,
+          baseUrl: this.config.baseUrl
+        },
+        onMessage,
+        onError
+      );
+    }
+    /**
+     * Stop listening for messages
+     */
+    stopListening(sessionId) {
+      this.streamManager.stopStream(sessionId);
+    }
+    /**
+     * Close client and clean up resources
+     */
+    close() {
+      this.streamManager.stopAllStreams();
+    }
+    /**
+     * Helper method to make HTTP requests
+     */
+    async _request(method, path, payload, timeout = DEFAULT_TIMEOUT_MS) {
+      const url = `${this.config.baseUrl}${path}`;
+      const headers = {
+        "Content-Type": "application/json",
+        "Authorization": formatAuthHeader(this.config.apiKey),
+        "X-Agent-ID": this.config.agentId
+      };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: payload ? JSON.stringify(payload) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          const errorMessage = errorData.error || errorData.message || response.statusText;
+          if (response.status === 401 || response.status === 403) {
+            throw new AuthenticationError(errorMessage);
+          } else if (response.status === 404) {
+            throw new SessionNotFoundError(payload?.session_id || "unknown");
+          } else if (response.status === 429) {
+            const retryAfter = response.headers.get("Retry-After");
+            throw new RateLimitError(errorMessage, retryAfter ? parseInt(retryAfter) : void 0);
+          } else if (response.status >= 500) {
+            throw new NetworkError(errorMessage, response.status);
+          } else {
+            throw new NetworkError(errorMessage, response.status);
+          }
+        }
+        return await response.json();
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof OlbrainError) {
+          throw error;
+        }
+        if (error instanceof TypeError) {
+          if (error.message.includes("aborted")) {
+            throw new OlbrainError(`Request timeout after ${timeout}ms`);
+          }
+          throw new NetworkError(error.message);
+        }
+        throw error;
+      }
+    }
+    /**
+     * Helper to parse session info from response
+     */
+    _parseSessionInfo(data) {
+      return {
+        sessionId: data.session_id,
+        title: data.title,
+        status: data.status || "active",
+        createdAt: data.created_at,
+        messageCount: data.message_count || 0,
+        userId: data.user_id,
+        metadata: data.metadata || {}
+      };
+    }
+  };
+
+  // src/index.ts
+  var VERSION = "1.0.0";
+
+  // src/widget/templates.ts
+  function widgetContainerTemplate(config) {
+    const theme = config.theme === "auto" ? "light" : config.theme;
+    return `
+    <div class="olbrain-widget-container" data-theme="${theme}">
+      <div class="olbrain-chat-widget">
+        <div class="olbrain-chat-header">
+          <div class="olbrain-chat-title">${escapeHtml(config.title)}</div>
+          <button class="olbrain-close-btn" aria-label="Close chat">
+            <svg width="20" height="20" viewBox="0 0 20 20" fill="currentColor">
+              <path d="M15.898 4.045l-5.307 5.307 5.307 5.307c.39.39.39 1.025 0 1.415-.195.195-.45.292-.707.292-.257 0-.512-.097-.707-.292l-5.307-5.307-5.307 5.307c-.195.195-.45.292-.707.292-.257 0-.512-.097-.707-.292-.39-.39-.39-1.025 0-1.415l5.307-5.307-5.307-5.307c-.39-.39-.39-1.025 0-1.415.39-.39 1.025-.39 1.415 0l5.307 5.307 5.307-5.307c.39-.39 1.025-.39 1.415 0 .39.39.39 1.025 0 1.415z"/>
+            </svg>
+          </button>
+        </div>
+        <div class="olbrain-messages-container"></div>
+        <div class="olbrain-input-area">
+          <input
+            type="text"
+            class="olbrain-message-input"
+            placeholder="${escapeHtml(config.placeholder)}"
+            aria-label="Message input"
+          />
+          <button class="olbrain-send-btn" aria-label="Send message">
+            <svg width="20" height="20" viewBox="0 0 20 20" fill="currentColor">
+              <path d="M16.6915026,12.4744748 L3.50612381,13.2599618 C3.19218622,13.2599618 3.03521743,13.4170592 3.03521743,13.5741566 L1.15159189,17.8274344 C0.8376543,18.6129214 0.99,19.3984083 1.77946707,20 C2.41,20.52 3.50612381,20.3429026 4.13399899,20.0274254 L21.714504,3.40596059 C22.6563168,2.59128963 22.6563168,0.9563 21.714504,0.1416 L4.13399899,-0.4800539 C3.50612381,-0.4800539 2.40880848,0.0729863 1.77946707,0.7844625 C0.994041701,1.5699495 0.837158534,2.35644751 1.15159189,3.1419345 L3.03521743,7.39521227 C3.03521743,7.55230969 3.34915502,7.70940711 3.50612381,7.70940711 L16.6915026,8.49489406 C16.6915026,8.49489406 17.1272231,8.49489406 17.1272231,8.99410899 L17.1272231,11.8231405 C17.1272231,12.3223555 16.6915026,12.4744748 16.6915026,12.4744748 Z"/>
+            </svg>
+          </button>
+        </div>
+      </div>
+      <button class="olbrain-toggle-btn" aria-label="Toggle chat widget">
+        <svg width="24" height="24" viewBox="0 0 24 24" fill="currentColor">
+          <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm3.5-9c.83 0 1.5-.67 1.5-1.5S16.33 8 15.5 8 14 8.67 14 9.5s.67 1.5 1.5 1.5zm-7 0c.83 0 1.5-.67 1.5-1.5S9.33 8 8.5 8 7 8.67 7 9.5 7.67 11 8.5 11zm3.5 6.5c2.33 0 4.31-1.46 5.11-3.5H6.89c.8 2.04 2.78 3.5 5.11 3.5z"/>
+        </svg>
+      </button>
+    </div>
+  `;
+  }
+  function userMessageTemplate(content, timestamp) {
+    return `
+    <div class="olbrain-message olbrain-message-user">
+      <div class="olbrain-message-content">${escapeHtml(content)}</div>
+      <div class="olbrain-message-time">${formatTime(timestamp)}</div>
+    </div>
+  `;
+  }
+  function assistantMessageTemplate(content, timestamp) {
+    return `
+    <div class="olbrain-message olbrain-message-assistant">
+      <div class="olbrain-message-content">${escapeHtml(content)}</div>
+      <div class="olbrain-message-time">${formatTime(timestamp)}</div>
+    </div>
+  `;
+  }
+  function typingIndicatorTemplate() {
+    return `
+    <div class="olbrain-message olbrain-message-assistant">
+      <div class="olbrain-typing-indicator">
+        <span></span>
+        <span></span>
+        <span></span>
+      </div>
+    </div>
+  `;
+  }
+  function errorMessageTemplate(error) {
+    return `
+    <div class="olbrain-message olbrain-message-error">
+      <div class="olbrain-message-content">Error: ${escapeHtml(error)}</div>
+    </div>
+  `;
+  }
+  function greetingTemplate(greeting) {
+    return `
+    <div class="olbrain-message olbrain-message-greeting">
+      <div class="olbrain-message-content">${escapeHtml(greeting)}</div>
+    </div>
+  `;
+  }
+  function escapeHtml(text) {
+    const div = document.createElement("div");
+    div.textContent = text;
+    return div.innerHTML;
+  }
+  function formatTime(timestamp) {
+    try {
+      const date = new Date(timestamp);
+      const hours = date.getHours().toString().padStart(2, "0");
+      const minutes = date.getMinutes().toString().padStart(2, "0");
+      return `${hours}:${minutes}`;
+    } catch {
+      return "";
+    }
+  }
+
+  // src/widget/styles.ts
+  function generateStyles(config) {
+    const primary = config.primaryColor || "#4f46e5";
+    const isDark = config.theme === "dark";
+    const bgColor = isDark ? "#1f2937" : "#ffffff";
+    const textColor = isDark ? "#f3f4f6" : "#111827";
+    const borderColor = isDark ? "#374151" : "#e5e7eb";
+    const hoverBg = isDark ? "#111827" : "#f9fafb";
+    return `
+    .olbrain-widget-container {
+      --primary-color: ${primary};
+      --bg-color: ${bgColor};
+      --text-color: ${textColor};
+      --border-color: ${borderColor};
+      --hover-bg: ${hoverBg};
+
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+        'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+        sans-serif;
+      -webkit-font-smoothing: antialiased;
+      -moz-osx-font-smoothing: grayscale;
+    }
+
+    .olbrain-widget-container * {
+      box-sizing: border-box;
+    }
+
+    .olbrain-widget-container[data-theme="dark"] {
+      color-scheme: dark;
+    }
+
+    .olbrain-widget-container[data-theme="light"] {
+      color-scheme: light;
+    }
+
+    /* Toggle Button */
+    .olbrain-toggle-btn {
+      position: fixed;
+      bottom: 24px;
+      right: 24px;
+      width: 56px;
+      height: 56px;
+      border-radius: 50%;
+      background-color: var(--primary-color);
+      border: none;
+      color: white;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+      transition: all 0.3s ease;
+      z-index: 999999;
+    }
+
+    .olbrain-toggle-btn:hover {
+      transform: scale(1.1);
+      box-shadow: 0 6px 16px rgba(0, 0, 0, 0.2);
+    }
+
+    .olbrain-toggle-btn:active {
+      transform: scale(0.95);
+    }
+
+    .olbrain-toggle-btn.hidden {
+      display: none;
+    }
+
+    /* Chat Widget Container */
+    .olbrain-chat-widget {
+      position: fixed;
+      bottom: 100px;
+      right: 24px;
+      width: 420px;
+      max-width: calc(100vw - 32px);
+      height: 600px;
+      max-height: calc(100vh - 140px);
+      background-color: var(--bg-color);
+      border-radius: 12px;
+      box-shadow: 0 5px 40px rgba(0, 0, 0, 0.16);
+      display: flex;
+      flex-direction: column;
+      z-index: 999998;
+      animation: slideUp 0.3s ease;
+      opacity: 0;
+      pointer-events: none;
+      transform: translateY(20px);
+    }
+
+    .olbrain-chat-widget.open {
+      opacity: 1;
+      pointer-events: auto;
+      transform: translateY(0);
+    }
+
+    @keyframes slideUp {
+      from {
+        opacity: 0;
+        transform: translateY(20px);
+      }
+      to {
+        opacity: 1;
+        transform: translateY(0);
+      }
+    }
+
+    /* Chat Header */
+    .olbrain-chat-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      padding: 16px;
+      border-bottom: 1px solid var(--border-color);
+      border-radius: 12px 12px 0 0;
+      background: linear-gradient(135deg, var(--primary-color), color-mix(in srgb, var(--primary-color) 80%, black));
+      color: white;
+    }
+
+    .olbrain-chat-title {
+      font-size: 16px;
+      font-weight: 600;
+    }
+
+    .olbrain-close-btn {
+      background: none;
+      border: none;
+      color: white;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 4px;
+      border-radius: 4px;
+      transition: background-color 0.2s;
+    }
+
+    .olbrain-close-btn:hover {
+      background-color: rgba(255, 255, 255, 0.2);
+    }
+
+    /* Messages Container */
+    .olbrain-messages-container {
+      flex: 1;
+      overflow-y: auto;
+      padding: 16px;
+      display: flex;
+      flex-direction: column;
+      gap: 12px;
+      background-color: var(--bg-color);
+    }
+
+    .olbrain-messages-container::-webkit-scrollbar {
+      width: 6px;
+    }
+
+    .olbrain-messages-container::-webkit-scrollbar-track {
+      background: transparent;
+    }
+
+    .olbrain-messages-container::-webkit-scrollbar-thumb {
+      background: var(--border-color);
+      border-radius: 3px;
+    }
+
+    .olbrain-messages-container::-webkit-scrollbar-thumb:hover {
+      background: color-mix(in srgb, var(--border-color) 80%, black);
+    }
+
+    /* Message */
+    .olbrain-message {
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+      animation: fadeIn 0.3s ease;
+    }
+
+    @keyframes fadeIn {
+      from {
+        opacity: 0;
+        transform: translateY(10px);
+      }
+      to {
+        opacity: 1;
+        transform: translateY(0);
+      }
+    }
+
+    .olbrain-message-content {
+      max-width: 85%;
+      padding: 12px 16px;
+      border-radius: 8px;
+      word-wrap: break-word;
+      line-height: 1.4;
+      font-size: 14px;
+    }
+
+    /* User Message */
+    .olbrain-message-user .olbrain-message-content {
+      background-color: var(--primary-color);
+      color: white;
+      align-self: flex-end;
+      border-radius: 18px 18px 4px 18px;
+    }
+
+    /* Assistant Message */
+    .olbrain-message-assistant .olbrain-message-content {
+      background-color: var(--hover-bg);
+      color: var(--text-color);
+      align-self: flex-start;
+      border-radius: 18px 18px 18px 4px;
+    }
+
+    /* Greeting Message */
+    .olbrain-message-greeting .olbrain-message-content {
+      background-color: transparent;
+      color: var(--text-color);
+      align-self: center;
+      font-style: italic;
+      opacity: 0.7;
+      padding: 8px 12px;
+    }
+
+    /* Error Message */
+    .olbrain-message-error .olbrain-message-content {
+      background-color: #fee;
+      color: #c33;
+      align-self: flex-start;
+    }
+
+    .olbrain-message-time {
+      font-size: 12px;
+      color: var(--text-color);
+      opacity: 0.6;
+      padding: 0 16px;
+    }
+
+    /* Typing Indicator */
+    .olbrain-typing-indicator {
+      display: flex;
+      gap: 4px;
+      padding: 12px 16px;
+    }
+
+    .olbrain-typing-indicator span {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background-color: var(--text-color);
+      opacity: 0.4;
+      animation: typing 1.4s infinite;
+    }
+
+    .olbrain-typing-indicator span:nth-child(2) {
+      animation-delay: 0.2s;
+    }
+
+    .olbrain-typing-indicator span:nth-child(3) {
+      animation-delay: 0.4s;
+    }
+
+    @keyframes typing {
+      0%, 60%, 100% {
+        opacity: 0.4;
+        transform: translateY(0);
+      }
+      30% {
+        opacity: 1;
+        transform: translateY(-10px);
+      }
+    }
+
+    /* Input Area */
+    .olbrain-input-area {
+      display: flex;
+      gap: 8px;
+      padding: 16px;
+      border-top: 1px solid var(--border-color);
+      background-color: var(--bg-color);
+      border-radius: 0 0 12px 12px;
+    }
+
+    .olbrain-message-input {
+      flex: 1;
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      padding: 10px 14px;
+      font-size: 14px;
+      font-family: inherit;
+      background-color: var(--hover-bg);
+      color: var(--text-color);
+      transition: border-color 0.2s;
+    }
+
+    .olbrain-message-input:focus {
+      outline: none;
+      border-color: var(--primary-color);
+      box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary-color) 20%, transparent);
+    }
+
+    .olbrain-message-input::placeholder {
+      color: var(--text-color);
+      opacity: 0.5;
+    }
+
+    .olbrain-send-btn {
+      background-color: var(--primary-color);
+      border: none;
+      color: white;
+      border-radius: 8px;
+      width: 40px;
+      height: 40px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      cursor: pointer;
+      transition: all 0.2s;
+    }
+
+    .olbrain-send-btn:hover {
+      transform: scale(1.05);
+      box-shadow: 0 2px 8px color-mix(in srgb, var(--primary-color) 30%, transparent);
+    }
+
+    .olbrain-send-btn:active {
+      transform: scale(0.95);
+    }
+
+    .olbrain-send-btn:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+      transform: none;
+    }
+
+    /* Mobile Responsive */
+    @media (max-width: 480px) {
+      .olbrain-chat-widget {
+        width: calc(100vw - 32px);
+        height: calc(100vh - 140px);
+        bottom: 100px;
+        right: 16px;
+        border-radius: 8px;
+      }
+
+      .olbrain-toggle-btn {
+        width: 48px;
+        height: 48px;
+        bottom: 20px;
+        right: 16px;
+      }
+
+      .olbrain-message-content {
+        max-width: 90%;
+      }
+    }
+  `;
+  }
+
+  // src/widget/ChatWidget.ts
+  var DEFAULT_GREETING = "Hi! How can I help you today?";
+  var DEFAULT_TITLE = "Chat with us";
+  var DEFAULT_PLACEHOLDER = "Type your message...";
+  var DEFAULT_PRIMARY_COLOR = "#4f46e5";
+  var SESSION_STORAGE_KEY = "olbrain_widget_session_id";
+  var ChatWidget = class {
+    constructor(config) {
+      this.sessionId = null;
+      this.container = null;
+      this.chatWidget = null;
+      this.toggleBtn = null;
+      this.messagesContainer = null;
+      this.messageInput = null;
+      this.sendBtn = null;
+      this.isOpen = false;
+      this.isWaitingForResponse = false;
+      this.config = this._normalizeConfig(config);
+      this.client = new AgentClient({
+        agentId: config.agentId,
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl
+      });
+    }
+    /**
+     * Mount widget to the page
+     */
+    async mount(target) {
+      this._injectStyles();
+      if (target) {
+        if (typeof target === "string") {
+          this.container = document.querySelector(target);
+          if (!this.container) {
+            throw new Error(`Element with selector "${target}" not found`);
+          }
+        } else {
+          this.container = target;
+        }
+      } else {
+        this.container = document.body;
+      }
+      this._render();
+      this._attachEventListeners();
+      await this._initializeSession();
+      this._showGreeting();
+      if (this.config.autoOpen) {
+        this.open();
+      }
+    }
+    /**
+     * Unmount widget from the page
+     */
+    unmount() {
+      this.client.stopListening(this.sessionId || "");
+      this.client.close();
+      if (this.container) {
+        const wrapper = this.container.querySelector(".olbrain-widget-container");
+        if (wrapper) {
+          wrapper.remove();
+        }
+      }
+      this.container = null;
+    }
+    /**
+     * Open chat window
+     */
+    open() {
+      if (this.chatWidget) {
+        this.chatWidget.classList.add("open");
+        this.isOpen = true;
+        if (this.messageInput) {
+          this.messageInput.focus();
+        }
+      }
+    }
+    /**
+     * Close chat window
+     */
+    close() {
+      if (this.chatWidget) {
+        this.chatWidget.classList.remove("open");
+        this.isOpen = false;
+      }
+    }
+    /**
+     * Send a message
+     */
+    async sendMessage(text) {
+      if (!text.trim() || !this.sessionId || this.isWaitingForResponse) {
+        return;
+      }
+      this._addMessageToUI(text, "user");
+      if (this.messageInput) {
+        this.messageInput.value = "";
+      }
+      this.isWaitingForResponse = true;
+      try {
+        this._showTypingIndicator();
+        const response = await this.client.sendAndWait(this.sessionId, text);
+        this._removeTypingIndicator();
+        if (response.success && response.text) {
+          this._addMessageToUI(response.text, "assistant");
+        } else if (response.error) {
+          this._showError(response.error);
+        }
+      } catch (error) {
+        this._removeTypingIndicator();
+        this._showError(error.message);
+      } finally {
+        this.isWaitingForResponse = false;
+      }
+    }
+    /**
+     * Normalize configuration with defaults
+     */
+    _normalizeConfig(config) {
+      return {
+        agentId: config.agentId,
+        apiKey: config.apiKey,
+        position: config.position || "bottom-right",
+        theme: config.theme || "auto",
+        primaryColor: config.primaryColor || DEFAULT_PRIMARY_COLOR,
+        title: config.title || DEFAULT_TITLE,
+        greeting: config.greeting || DEFAULT_GREETING,
+        placeholder: config.placeholder || DEFAULT_PLACEHOLDER,
+        autoOpen: config.autoOpen ?? false,
+        persistSession: config.persistSession ?? true,
+        target: config.target || document.body,
+        onMessage: config.onMessage || (() => {
+        }),
+        baseUrl: config.baseUrl || ""
+      };
+    }
+    /**
+     * Inject widget styles into the page
+     */
+    _injectStyles() {
+      if (document.getElementById("olbrain-widget-styles")) {
+        return;
+      }
+      const styleEl = document.createElement("style");
+      styleEl.id = "olbrain-widget-styles";
+      styleEl.textContent = generateStyles({
+        primaryColor: this.config.primaryColor,
+        theme: this.config.theme
+      });
+      document.head.appendChild(styleEl);
+    }
+    /**
+     * Render widget HTML
+     */
+    _render() {
+      if (!this.container) return;
+      const html = widgetContainerTemplate({
+        title: this.config.title,
+        greeting: this.config.greeting,
+        placeholder: this.config.placeholder,
+        theme: this.config.theme
+      });
+      this.container.insertAdjacentHTML("beforeend", html);
+      const wrapper = this.container.querySelector(".olbrain-widget-container");
+      if (wrapper) {
+        this.chatWidget = wrapper.querySelector(".olbrain-chat-widget");
+        this.toggleBtn = wrapper.querySelector(".olbrain-toggle-btn");
+        this.messagesContainer = wrapper.querySelector(".olbrain-messages-container");
+        this.messageInput = wrapper.querySelector(".olbrain-message-input");
+        this.sendBtn = wrapper.querySelector(".olbrain-send-btn");
+      }
+    }
+    /**
+     * Attach event listeners
+     */
+    _attachEventListeners() {
+      this.toggleBtn?.addEventListener("click", () => {
+        this.isOpen ? this.close() : this.open();
+        this.toggleBtn?.classList.toggle("hidden", this.isOpen);
+      });
+      this.chatWidget?.querySelector(".olbrain-close-btn")?.addEventListener("click", () => this.close());
+      this.sendBtn?.addEventListener("click", () => {
+        if (this.messageInput) {
+          this.sendMessage(this.messageInput.value);
+        }
+      });
+      this.messageInput?.addEventListener("keypress", (e) => {
+        if (e.key === "Enter" && !e.shiftKey) {
+          e.preventDefault();
+          if (this.messageInput) {
+            this.sendMessage(this.messageInput.value);
+          }
+        }
+      });
+      this.messageInput?.addEventListener("input", () => {
+        if (this.sendBtn) {
+          this.sendBtn.disabled = this.isWaitingForResponse;
+        }
+      });
+    }
+    /**
+     * Initialize session (load or create)
+     */
+    async _initializeSession() {
+      if (this.config.persistSession) {
+        const savedSessionId = this._getStoredSessionId();
+        if (savedSessionId) {
+          try {
+            await this.client.getSession(savedSessionId);
+            this.sessionId = savedSessionId;
+            return;
+          } catch {
+          }
+        }
+      }
+      try {
+        this.sessionId = await this.client.createSession({
+          title: "Widget Chat Session",
+          metadata: {
+            source: "chat_widget"
+          }
+        });
+        if (this.config.persistSession) {
+          this._storeSessionId(this.sessionId);
+        }
+      } catch (error) {
+        this._showError(`Failed to create session: ${error.message}`);
+      }
+    }
+    /**
+     * Show greeting message
+     */
+    _showGreeting() {
+      if (this.messagesContainer) {
+        const html = greetingTemplate(this.config.greeting);
+        this.messagesContainer.insertAdjacentHTML("beforeend", html);
+        this._scrollToBottom();
+      }
+    }
+    /**
+     * Add message to UI
+     */
+    _addMessageToUI(content, role) {
+      if (!this.messagesContainer) return;
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const html = role === "user" ? userMessageTemplate(content, timestamp) : assistantMessageTemplate(content, timestamp);
+      this.messagesContainer.insertAdjacentHTML("beforeend", html);
+      this._scrollToBottom();
+      if (this.config.onMessage) {
+        this.config.onMessage({
+          role,
+          content,
+          timestamp,
+          metadata: {}
+        });
+      }
+    }
+    /**
+     * Show typing indicator
+     */
+    _showTypingIndicator() {
+      if (!this.messagesContainer) return;
+      const html = typingIndicatorTemplate();
+      this.messagesContainer.insertAdjacentHTML("beforeend", html);
+      this._scrollToBottom();
+    }
+    /**
+     * Remove typing indicator
+     */
+    _removeTypingIndicator() {
+      const indicator = this.messagesContainer?.querySelector(".olbrain-typing-indicator");
+      if (indicator) {
+        indicator.closest(".olbrain-message")?.remove();
+      }
+    }
+    /**
+     * Show error message
+     */
+    _showError(error) {
+      if (!this.messagesContainer) return;
+      const html = errorMessageTemplate(error);
+      this.messagesContainer.insertAdjacentHTML("beforeend", html);
+      this._scrollToBottom();
+    }
+    /**
+     * Scroll to bottom of messages
+     */
+    _scrollToBottom() {
+      if (this.messagesContainer) {
+        setTimeout(() => {
+          this.messagesContainer.scrollTop = this.messagesContainer.scrollHeight;
+        }, 0);
+      }
+    }
+    /**
+     * Store session ID in localStorage
+     */
+    _storeSessionId(sessionId) {
+      try {
+        if (typeof localStorage !== "undefined") {
+          localStorage.setItem(SESSION_STORAGE_KEY, sessionId);
+        }
+      } catch {
+      }
+    }
+    /**
+     * Get stored session ID from localStorage
+     */
+    _getStoredSessionId() {
+      try {
+        if (typeof localStorage !== "undefined") {
+          return localStorage.getItem(SESSION_STORAGE_KEY);
+        }
+      } catch {
+      }
+      return null;
+    }
+  };
+  return __toCommonJS(widget_exports);
+})();
+//# sourceMappingURL=widget.widget.global.js.map