@olbrain/js-sdk 1.0.0

package/dist/index.global.js

@@ -0,0 +1,979 @@
+"use strict";
+var Olbrain = (() => {
+  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/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    AgentClient: () => AgentClient,
+    AuthenticationError: () => AuthenticationError,
+    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";
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map