agentxjs 1.0.2 → 1.1.0

package/dist/browser.cjs

@@ -1,709 +1,14 @@
 'use strict';
 
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+var agentx = require('@agentxjs/types/agentx');
+var event = require('@agentxjs/types/event');
+var common = require('@agentxjs/common');
 
-// ../common/dist/index.js
-function createLogger(name) {
-  return LoggerFactoryImpl.getLogger(name);
-}
-var __defProp2, __defNormalProp, __publicField, _ConsoleLogger, ConsoleLogger, externalFactory, LoggerFactoryImpl;
-var init_dist = __esm({
-  "../common/dist/index.js"() {
-    __defProp2 = Object.defineProperty;
-    __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-    __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    _ConsoleLogger = class _ConsoleLogger2 {
-      constructor(name, options = {}) {
-        __publicField(this, "name");
-        __publicField(this, "level");
-        __publicField(this, "colors");
-        __publicField(this, "timestamps");
-        this.name = name;
-        this.level = options.level ?? "info";
-        this.colors = options.colors ?? this.isNodeEnvironment();
-        this.timestamps = options.timestamps ?? true;
-      }
-      debug(message, context) {
-        if (this.isDebugEnabled()) {
-          this.log("DEBUG", message, context);
-        }
-      }
-      info(message, context) {
-        if (this.isInfoEnabled()) {
-          this.log("INFO", message, context);
-        }
-      }
-      warn(message, context) {
-        if (this.isWarnEnabled()) {
-          this.log("WARN", message, context);
-        }
-      }
-      error(message, context) {
-        if (this.isErrorEnabled()) {
-          if (message instanceof Error) {
-            this.log("ERROR", message.message, { ...context, stack: message.stack });
-          } else {
-            this.log("ERROR", message, context);
-          }
-        }
-      }
-      isDebugEnabled() {
-        return this.getLevelValue(this.level) <= this.getLevelValue("debug");
-      }
-      isInfoEnabled() {
-        return this.getLevelValue(this.level) <= this.getLevelValue("info");
-      }
-      isWarnEnabled() {
-        return this.getLevelValue(this.level) <= this.getLevelValue("warn");
-      }
-      isErrorEnabled() {
-        return this.getLevelValue(this.level) <= this.getLevelValue("error");
-      }
-      getLevelValue(level) {
-        const levels = {
-          debug: 0,
-          info: 1,
-          warn: 2,
-          error: 3,
-          silent: 4
-        };
-        return levels[level];
-      }
-      log(level, message, context) {
-        const parts = [];
-        if (this.timestamps) {
-          parts.push((/* @__PURE__ */ new Date()).toISOString());
-        }
-        if (this.colors) {
-          const color = _ConsoleLogger2.COLORS[level];
-          parts.push(`${color}${level.padEnd(5)}${_ConsoleLogger2.COLORS.RESET}`);
-        } else {
-          parts.push(level.padEnd(5));
-        }
-        parts.push(`[${this.name}]`);
-        parts.push(message);
-        const logLine = parts.join(" ");
-        const consoleMethod = this.getConsoleMethod(level);
-        if (context && Object.keys(context).length > 0) {
-          consoleMethod(logLine, context);
-        } else {
-          consoleMethod(logLine);
-        }
-      }
-      getConsoleMethod(level) {
-        switch (level) {
-          case "DEBUG":
-            return console.debug.bind(console);
-          case "INFO":
-            return console.info.bind(console);
-          case "WARN":
-            return console.warn.bind(console);
-          case "ERROR":
-            return console.error.bind(console);
-          default:
-            return console.log.bind(console);
-        }
-      }
-      isNodeEnvironment() {
-        return typeof process !== "undefined" && process.versions?.node !== void 0;
-      }
-    };
-    __publicField(_ConsoleLogger, "COLORS", {
-      DEBUG: "\x1B[36m",
-      INFO: "\x1B[32m",
-      WARN: "\x1B[33m",
-      ERROR: "\x1B[31m",
-      RESET: "\x1B[0m"
-    });
-    ConsoleLogger = _ConsoleLogger;
-    externalFactory = null;
-    LoggerFactoryImpl = class {
-      static getLogger(nameOrClass) {
-        const name = typeof nameOrClass === "string" ? nameOrClass : nameOrClass.name;
-        if (this.loggers.has(name)) {
-          return this.loggers.get(name);
-        }
-        const lazyLogger = this.createLazyLogger(name);
-        this.loggers.set(name, lazyLogger);
-        return lazyLogger;
-      }
-      static configure(config) {
-        this.config = { ...this.config, ...config };
-      }
-      static reset() {
-        this.loggers.clear();
-        this.config = { defaultLevel: "info" };
-        externalFactory = null;
-      }
-      static createLazyLogger(name) {
-        let realLogger = null;
-        const getRealLogger = () => {
-          if (!realLogger) {
-            realLogger = this.createLogger(name);
-          }
-          return realLogger;
-        };
-        return {
-          name,
-          level: this.config.defaultLevel || "info",
-          debug: (message, context) => getRealLogger().debug(message, context),
-          info: (message, context) => getRealLogger().info(message, context),
-          warn: (message, context) => getRealLogger().warn(message, context),
-          error: (message, context) => getRealLogger().error(message, context),
-          isDebugEnabled: () => getRealLogger().isDebugEnabled(),
-          isInfoEnabled: () => getRealLogger().isInfoEnabled(),
-          isWarnEnabled: () => getRealLogger().isWarnEnabled(),
-          isErrorEnabled: () => getRealLogger().isErrorEnabled()
-        };
-      }
-      static createLogger(name) {
-        if (externalFactory) {
-          return externalFactory.getLogger(name);
-        }
-        if (this.config.defaultImplementation) {
-          return this.config.defaultImplementation(name);
-        }
-        return new ConsoleLogger(name, {
-          level: this.config.defaultLevel,
-          ...this.config.consoleOptions
-        });
-      }
-    };
-    __publicField(LoggerFactoryImpl, "loggers", /* @__PURE__ */ new Map());
-    __publicField(LoggerFactoryImpl, "config", {
-      defaultLevel: "info"
-    });
-  }
-});
-
-// ../network/dist/chunk-63P5VUHB.js
-async function createWebSocketClient(options) {
-  if (isBrowser) {
-    const client = new BrowserWebSocketClient(options);
-    await client.connect();
-    return client;
-  } else {
-    const client = new WebSocketClient(options);
-    await client.connect();
-    return client;
-  }
-}
-var __defProp3, __defNormalProp2, __publicField2, logger, isBrowser, WebSocketClient, BrowserWebSocketClient;
-var init_chunk_63P5VUHB = __esm({
-  "../network/dist/chunk-63P5VUHB.js"() {
-    init_dist();
-    __defProp3 = Object.defineProperty;
-    __defNormalProp2 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-    __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
-    logger = createLogger("network/WebSocketClient");
-    isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window.WebSocket !== "undefined";
-    WebSocketClient = class {
-      constructor(options) {
-        __publicField2(this, "ws", null);
-        __publicField2(this, "serverUrl");
-        __publicField2(this, "messageHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "openHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "closeHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "errorHandlers", /* @__PURE__ */ new Set());
-        if (isBrowser) {
-          throw new Error(
-            "Use createBrowserWebSocketClient() in browser environment for auto-reconnect support"
-          );
-        }
-        this.serverUrl = options.serverUrl;
-      }
-      get readyState() {
-        if (!this.ws) return "closed";
-        const state = this.ws.readyState;
-        if (state === 0) return "connecting";
-        if (state === 1) return "open";
-        if (state === 2) return "closing";
-        return "closed";
-      }
-      async connect() {
-        if (this.ws) {
-          throw new Error("Already connected or connecting");
-        }
-        const { WebSocket: NodeWebSocket } = await import('ws');
-        this.ws = new NodeWebSocket(this.serverUrl);
-        return new Promise((resolve, reject) => {
-          const onOpen = () => {
-            logger.info("WebSocket connected", { serverUrl: this.serverUrl });
-            for (const handler of this.openHandlers) {
-              handler();
-            }
-            resolve();
-          };
-          const onError = (err) => {
-            logger.error("WebSocket connection failed", {
-              serverUrl: this.serverUrl,
-              error: err?.message
-            });
-            reject(err || new Error("WebSocket connection failed"));
-          };
-          this.ws.once("open", onOpen);
-          this.ws.once("error", onError);
-          this.ws.on("message", (data) => {
-            const message = data.toString();
-            for (const handler of this.messageHandlers) {
-              handler(message);
-            }
-          });
-          this.ws.on("close", () => {
-            logger.warn("WebSocket closed");
-            for (const handler of this.closeHandlers) {
-              handler();
-            }
-          });
-          this.ws.on("error", (err) => {
-            logger.error("WebSocket error", { error: err.message });
-            for (const handler of this.errorHandlers) {
-              handler(err);
-            }
-          });
-        });
-      }
-      send(message) {
-        if (!this.ws || this.ws.readyState !== 1) {
-          throw new Error("WebSocket is not open");
-        }
-        this.ws.send(message);
-      }
-      onMessage(handler) {
-        this.messageHandlers.add(handler);
-        return () => {
-          this.messageHandlers.delete(handler);
-        };
-      }
-      onOpen(handler) {
-        this.openHandlers.add(handler);
-        return () => {
-          this.openHandlers.delete(handler);
-        };
-      }
-      onClose(handler) {
-        this.closeHandlers.add(handler);
-        return () => {
-          this.closeHandlers.delete(handler);
-        };
-      }
-      onError(handler) {
-        this.errorHandlers.add(handler);
-        return () => {
-          this.errorHandlers.delete(handler);
-        };
-      }
-      close() {
-        if (this.ws) {
-          this.ws.close();
-          this.ws = null;
-        }
-      }
-      dispose() {
-        this.close();
-        this.messageHandlers.clear();
-        this.openHandlers.clear();
-        this.closeHandlers.clear();
-        this.errorHandlers.clear();
-      }
-    };
-    BrowserWebSocketClient = class {
-      // Track if this is a reconnection
-      constructor(options) {
-        __publicField2(this, "ws", null);
-        __publicField2(this, "serverUrl");
-        __publicField2(this, "options");
-        __publicField2(this, "messageHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "openHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "closeHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "errorHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "hasConnectedBefore", false);
-        if (!isBrowser) {
-          throw new Error("BrowserWebSocketClient can only be used in browser environment");
-        }
-        this.serverUrl = options.serverUrl;
-        this.options = {
-          autoReconnect: true,
-          minReconnectionDelay: 1e3,
-          maxReconnectionDelay: 1e4,
-          maxRetries: Infinity,
-          connectionTimeout: 4e3,
-          debug: false,
-          ...options
-        };
-      }
-      get readyState() {
-        if (!this.ws) return "closed";
-        const state = this.ws.readyState;
-        if (state === 0) return "connecting";
-        if (state === 1) return "open";
-        if (state === 2) return "closing";
-        return "closed";
-      }
-      async connect() {
-        if (this.ws) {
-          throw new Error("Already connected or connecting");
-        }
-        if (this.options.autoReconnect) {
-          const ReconnectingWebSocket = (await import('reconnecting-websocket')).default;
-          this.ws = new ReconnectingWebSocket(this.serverUrl, [], {
-            maxReconnectionDelay: this.options.maxReconnectionDelay,
-            minReconnectionDelay: this.options.minReconnectionDelay,
-            reconnectionDelayGrowFactor: 1.3,
-            connectionTimeout: this.options.connectionTimeout,
-            maxRetries: this.options.maxRetries,
-            debug: this.options.debug
-          });
-        } else {
-          this.ws = new WebSocket(this.serverUrl);
-        }
-        return new Promise((resolve, reject) => {
-          const onOpen = () => {
-            if (this.hasConnectedBefore) {
-              logger.info("WebSocket reconnected successfully", { serverUrl: this.serverUrl });
-            } else {
-              logger.info("WebSocket connected", { serverUrl: this.serverUrl });
-              this.hasConnectedBefore = true;
-            }
-            for (const handler of this.openHandlers) {
-              handler();
-            }
-            resolve();
-          };
-          const onError = (_event) => {
-            logger.error("WebSocket connection failed", { serverUrl: this.serverUrl });
-            const error = new Error("WebSocket connection failed");
-            for (const handler of this.errorHandlers) {
-              handler(error);
-            }
-            reject(error);
-          };
-          this.ws.addEventListener("open", onOpen, { once: true });
-          this.ws.addEventListener("error", onError, { once: true });
-          this.ws.addEventListener("message", ((event) => {
-            const message = event.data;
-            for (const handler of this.messageHandlers) {
-              handler(message);
-            }
-          }));
-          this.ws.addEventListener("close", (() => {
-            logger.info("WebSocket closed, attempting to reconnect...");
-            for (const handler of this.closeHandlers) {
-              handler();
-            }
-          }));
-          this.ws.addEventListener("error", ((_event) => {
-            logger.error("WebSocket error");
-            const error = new Error("WebSocket error");
-            for (const handler of this.errorHandlers) {
-              handler(error);
-            }
-          }));
-        });
-      }
-      send(message) {
-        if (!this.ws || this.ws.readyState !== 1) {
-          throw new Error("WebSocket is not open");
-        }
-        this.ws.send(message);
-      }
-      onMessage(handler) {
-        this.messageHandlers.add(handler);
-        return () => {
-          this.messageHandlers.delete(handler);
-        };
-      }
-      onOpen(handler) {
-        this.openHandlers.add(handler);
-        return () => {
-          this.openHandlers.delete(handler);
-        };
-      }
-      onClose(handler) {
-        this.closeHandlers.add(handler);
-        return () => {
-          this.closeHandlers.delete(handler);
-        };
-      }
-      onError(handler) {
-        this.errorHandlers.add(handler);
-        return () => {
-          this.errorHandlers.delete(handler);
-        };
-      }
-      close() {
-        if (this.ws) {
-          this.ws.close();
-          this.ws = null;
-        }
-      }
-      dispose() {
-        this.close();
-        this.messageHandlers.clear();
-        this.openHandlers.clear();
-        this.closeHandlers.clear();
-        this.errorHandlers.clear();
-      }
-    };
-  }
-});
-
-// ../network/dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
-  WebSocketClient: () => WebSocketClient,
-  WebSocketServer: () => WebSocketServer,
-  createWebSocketClient: () => createWebSocketClient
-});
-var logger2, WebSocketConnection, WebSocketServer;
-var init_dist2 = __esm({
-  "../network/dist/index.js"() {
-    init_chunk_63P5VUHB();
-    init_dist();
-    logger2 = createLogger("network/WebSocketServer");
-    WebSocketConnection = class {
-      constructor(ws, options) {
-        __publicField2(this, "id");
-        __publicField2(this, "ws");
-        __publicField2(this, "messageHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "closeHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "errorHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "heartbeatInterval");
-        __publicField2(this, "isAlive", true);
-        this.ws = ws;
-        this.id = `conn_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
-        if (options.heartbeat !== false) {
-          const interval = options.heartbeatInterval || 3e4;
-          ws.on("pong", () => {
-            this.isAlive = true;
-            logger2.debug("Heartbeat pong received", { id: this.id });
-          });
-          this.heartbeatInterval = setInterval(() => {
-            if (!this.isAlive) {
-              logger2.warn("Client heartbeat timeout, terminating connection", { id: this.id });
-              clearInterval(this.heartbeatInterval);
-              ws.terminate();
-              return;
-            }
-            this.isAlive = false;
-            ws.ping();
-            logger2.debug("Heartbeat ping sent", { id: this.id });
-          }, interval);
-        }
-        ws.on("message", (data) => {
-          const message = data.toString();
-          for (const handler of this.messageHandlers) {
-            handler(message);
-          }
-        });
-        ws.on("close", () => {
-          if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-          }
-          for (const handler of this.closeHandlers) {
-            handler();
-          }
-        });
-        ws.on("error", (err) => {
-          if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-          }
-          for (const handler of this.errorHandlers) {
-            handler(err);
-          }
-        });
-      }
-      send(message) {
-        if (this.ws.readyState === 1) {
-          this.ws.send(message);
-        }
-      }
-      onMessage(handler) {
-        this.messageHandlers.add(handler);
-        return () => {
-          this.messageHandlers.delete(handler);
-        };
-      }
-      onClose(handler) {
-        this.closeHandlers.add(handler);
-        return () => {
-          this.closeHandlers.delete(handler);
-        };
-      }
-      onError(handler) {
-        this.errorHandlers.add(handler);
-        return () => {
-          this.errorHandlers.delete(handler);
-        };
-      }
-      close() {
-        if (this.heartbeatInterval) {
-          clearInterval(this.heartbeatInterval);
-        }
-        this.ws.close();
-      }
-    };
-    WebSocketServer = class {
-      constructor(options = {}) {
-        __publicField2(this, "wss", null);
-        __publicField2(this, "connections", /* @__PURE__ */ new Set());
-        __publicField2(this, "connectionHandlers", /* @__PURE__ */ new Set());
-        __publicField2(this, "options");
-        __publicField2(this, "attachedToServer", false);
-        this.options = options;
-      }
-      async listen(port, host = "0.0.0.0") {
-        if (this.wss) {
-          throw new Error("Server already listening");
-        }
-        if (this.attachedToServer) {
-          throw new Error(
-            "Cannot listen when attached to existing server. The server should call listen() instead."
-          );
-        }
-        const { WebSocketServer: WSS } = await import('ws');
-        this.wss = new WSS({ port, host });
-        this.wss.on("connection", (ws) => {
-          this.handleConnection(ws);
-        });
-        logger2.info("WebSocket server listening", { port, host });
-      }
-      attach(server, path = "/ws") {
-        if (this.wss) {
-          throw new Error("Server already initialized");
-        }
-        import('ws').then(({ WebSocketServer: WSS }) => {
-          this.wss = new WSS({ noServer: true });
-          server.on("upgrade", (request, socket, head) => {
-            const url = new URL(request.url || "", `http://${request.headers.host}`);
-            if (url.pathname === path) {
-              this.wss.handleUpgrade(request, socket, head, (ws) => {
-                this.wss.emit("connection", ws, request);
-              });
-            } else {
-              socket.destroy();
-            }
-          });
-          this.wss.on("connection", (ws) => {
-            this.handleConnection(ws);
-          });
-          this.attachedToServer = true;
-          logger2.info("WebSocket attached to existing HTTP server", { path });
-        });
-      }
-      handleConnection(ws) {
-        const connection = new WebSocketConnection(ws, this.options);
-        this.connections.add(connection);
-        logger2.info("Client connected", {
-          connectionId: connection.id,
-          totalConnections: this.connections.size
-        });
-        connection.onClose(() => {
-          this.connections.delete(connection);
-          logger2.info("Client disconnected", {
-            connectionId: connection.id,
-            totalConnections: this.connections.size
-          });
-        });
-        for (const handler of this.connectionHandlers) {
-          handler(connection);
-        }
-      }
-      onConnection(handler) {
-        this.connectionHandlers.add(handler);
-        return () => {
-          this.connectionHandlers.delete(handler);
-        };
-      }
-      broadcast(message) {
-        for (const connection of this.connections) {
-          connection.send(message);
-        }
-      }
-      async close() {
-        if (!this.wss) return;
-        for (const connection of this.connections) {
-          connection.close();
-        }
-        this.connections.clear();
-        if (!this.attachedToServer) {
-          await new Promise((resolve) => {
-            this.wss.close(() => resolve());
-          });
-        }
-        this.wss = null;
-      }
-      async dispose() {
-        await this.close();
-        this.connectionHandlers.clear();
-      }
-    };
-  }
-});
-
-// ../types/dist/agentx.js
-function isRemoteConfig(config) {
-  return "serverUrl" in config && typeof config.serverUrl === "string";
-}
-function isLocalConfig(config) {
-  return !isRemoteConfig(config);
-}
-
-// ../types/dist/event.js
-function isFromSource(event, source) {
-  return event.source === source;
-}
-function hasIntent(event, intent) {
-  return event.intent === intent;
-}
-function isRequest(event) {
-  return event.intent === "request";
-}
-function isResult(event) {
-  return event.intent === "result";
-}
-function isNotification(event) {
-  return event.intent === "notification";
-}
-function isCommandEvent(event) {
-  return event.source === "command";
-}
-function isCommandRequest(event) {
-  return event.source === "command" && event.category === "request";
-}
-function isCommandResponse(event) {
-  return event.source === "command" && event.category === "response";
-}
-function isAgentStreamEvent(event) {
-  return event.source === "agent" && event.category === "stream";
-}
-function isAgentStateEvent(event) {
-  return event.source === "agent" && event.category === "state";
-}
-function isAgentMessageEvent(event) {
-  return event.source === "agent" && event.category === "message";
-}
-function isAgentTurnEvent(event) {
-  return event.source === "agent" && event.category === "turn";
-}
-function isAgentEvent(event) {
-  return event.source === "agent";
-}
-
-// src/createAgentX.ts
-init_dist();
-var remoteLogger = createLogger("agentx/RemoteClient");
+// src/browser.ts
+var remoteLogger = common.createLogger("agentx/RemoteClient");
 async function createRemoteAgentX(serverUrl) {
-  const { createWebSocketClient: createWebSocketClient2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
-  const client = await createWebSocketClient2({
+  const { createWebSocketClient } = await import('@agentxjs/network');
+  const client = await createWebSocketClient({
     serverUrl,
     autoReconnect: true,
     minReconnectionDelay: 1e3,
@@ -830,7 +135,7 @@ async function createRemoteAgentX(serverUrl) {
 
 // src/browser.ts
 async function createAgentX(config) {
-  if (!config || !isRemoteConfig(config)) {
+  if (!config || !agentx.isRemoteConfig(config)) {
     throw new Error(
       'Browser environment only supports remote mode. Please provide { serverUrl: "ws://..." } configuration.'
     );
@@ -838,22 +143,67 @@ async function createAgentX(config) {
   return createRemoteAgentX(config.serverUrl);
 }
 
+Object.defineProperty(exports, "isLocalConfig", {
+  enumerable: true,
+  get: function () { return agentx.isLocalConfig; }
+});
+Object.defineProperty(exports, "isRemoteConfig", {
+  enumerable: true,
+  get: function () { return agentx.isRemoteConfig; }
+});
+Object.defineProperty(exports, "hasIntent", {
+  enumerable: true,
+  get: function () { return event.hasIntent; }
+});
+Object.defineProperty(exports, "isAgentEvent", {
+  enumerable: true,
+  get: function () { return event.isAgentEvent; }
+});
+Object.defineProperty(exports, "isAgentMessageEvent", {
+  enumerable: true,
+  get: function () { return event.isAgentMessageEvent; }
+});
+Object.defineProperty(exports, "isAgentStateEvent", {
+  enumerable: true,
+  get: function () { return event.isAgentStateEvent; }
+});
+Object.defineProperty(exports, "isAgentStreamEvent", {
+  enumerable: true,
+  get: function () { return event.isAgentStreamEvent; }
+});
+Object.defineProperty(exports, "isAgentTurnEvent", {
+  enumerable: true,
+  get: function () { return event.isAgentTurnEvent; }
+});
+Object.defineProperty(exports, "isCommandEvent", {
+  enumerable: true,
+  get: function () { return event.isCommandEvent; }
+});
+Object.defineProperty(exports, "isCommandRequest", {
+  enumerable: true,
+  get: function () { return event.isCommandRequest; }
+});
+Object.defineProperty(exports, "isCommandResponse", {
+  enumerable: true,
+  get: function () { return event.isCommandResponse; }
+});
+Object.defineProperty(exports, "isFromSource", {
+  enumerable: true,
+  get: function () { return event.isFromSource; }
+});
+Object.defineProperty(exports, "isNotification", {
+  enumerable: true,
+  get: function () { return event.isNotification; }
+});
+Object.defineProperty(exports, "isRequest", {
+  enumerable: true,
+  get: function () { return event.isRequest; }
+});
+Object.defineProperty(exports, "isResult", {
+  enumerable: true,
+  get: function () { return event.isResult; }
+});
 exports.createAgentX = createAgentX;
 exports.createRemoteAgentX = createRemoteAgentX;
-exports.hasIntent = hasIntent;
-exports.isAgentEvent = isAgentEvent;
-exports.isAgentMessageEvent = isAgentMessageEvent;
-exports.isAgentStateEvent = isAgentStateEvent;
-exports.isAgentStreamEvent = isAgentStreamEvent;
-exports.isAgentTurnEvent = isAgentTurnEvent;
-exports.isCommandEvent = isCommandEvent;
-exports.isCommandRequest = isCommandRequest;
-exports.isCommandResponse = isCommandResponse;
-exports.isFromSource = isFromSource;
-exports.isLocalConfig = isLocalConfig;
-exports.isNotification = isNotification;
-exports.isRemoteConfig = isRemoteConfig;
-exports.isRequest = isRequest;
-exports.isResult = isResult;
 //# sourceMappingURL=browser.cjs.map
 //# sourceMappingURL=browser.cjs.map