@olbrain/js-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,1001 @@
+"use strict";
+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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  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/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/eventsource/lib/eventsource.js
+var require_eventsource = __commonJS({
+  "node_modules/eventsource/lib/eventsource.js"(exports2, module2) {
+    "use strict";
+    init_cjs_shims();
+    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;
+            }
+          }
+        }
+      }
+    }
+    module2.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
+});
+module.exports = __toCommonJS(index_exports);
+init_cjs_shims();
+
+// src/core/client.ts
+init_cjs_shims();
+
+// src/core/exceptions.ts
+init_cjs_shims();
+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
+init_cjs_shims();
+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
+init_cjs_shims();
+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";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentClient,
+  AuthenticationError,
+  NetworkError,
+  OlbrainError,
+  RateLimitError,
+  SessionNotFoundError,
+  StreamingError,
+  VERSION,
+  ValidationError
+});
+//# sourceMappingURL=index.js.map