agentxjs 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,5 +1,3 @@
-import { WebSocketServer } from '@agentxjs/network';
-
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -196,6 +194,471 @@ var init_dist = __esm({
   }
 });
 
+// ../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_exports2 = {};
+__export(dist_exports2, {
+  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();
+      }
+    };
+  }
+});
+
 // src/createLocalAgentX.ts
 var createLocalAgentX_exports = {};
 __export(createLocalAgentX_exports, {
@@ -277,6 +740,7 @@ async function createLocalAgentX(config) {
 }
 var init_createLocalAgentX = __esm({
   "src/createLocalAgentX.ts"() {
+    init_dist2();
   }
 });
 
@@ -299,8 +763,8 @@ async function createAgentX(config) {
   return createLocalAgentX2(config ?? {});
 }
 async function createRemoteAgentX(serverUrl) {
-  const { createWebSocketClient } = await import('@agentxjs/network');
-  const client = await createWebSocketClient({
+  const { createWebSocketClient: createWebSocketClient2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
+  const client = await createWebSocketClient2({
     serverUrl,
     autoReconnect: true,
     minReconnectionDelay: 1e3,