agentxjs 0.1.9 → 1.0.1

package/dist/index.js

@@ -194,48 +194,476 @@ 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, {
   createLocalAgentX: () => createLocalAgentX
 });
-function setupConnectionHandler(ws, connections, runtime) {
-  connections.add(ws);
-  logger.info("Client connected", { totalConnections: connections.size });
-  ws.on("message", (data) => {
-    try {
-      const event = JSON.parse(data.toString());
-      logger.info("Received from client", {
-        type: event.type,
-        requestId: event.data?.requestId
-      });
-      runtime.emit(event);
-    } catch {
-    }
-  });
-  ws.on("close", () => {
-    connections.delete(ws);
-    logger.info("Client disconnected", { totalConnections: connections.size });
-  });
-}
-function setupBroadcasting(connections, runtime) {
-  runtime.onAny((event) => {
-    if (event.broadcastable === false) {
-      return;
-    }
-    logger.info("Broadcasting to clients", {
-      type: event.type,
-      category: event.category,
-      requestId: event.data?.requestId
-    });
-    const message = JSON.stringify(event);
-    for (const ws of connections) {
-      if (ws.readyState === 1) {
-        ws.send(message);
-      }
-    }
-  });
-}
 async function createLocalAgentX(config) {
   if (config.logger) {
     const { LoggerFactoryImpl: LoggerFactoryImpl2, setLoggerFactory: setLoggerFactory2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
@@ -263,28 +691,28 @@ async function createLocalAgentX(config) {
       })
     }
   });
-  let peer = null;
-  const connections = /* @__PURE__ */ new Set();
-  let attachedToServer = false;
-  if (config.server) {
-    const { WebSocketServer } = await import('ws');
-    peer = new WebSocketServer({ noServer: true });
-    config.server.on("upgrade", (request, socket, head) => {
-      const url = new URL(request.url || "", `http://${request.headers.host}`);
-      if (url.pathname === "/ws") {
-        peer.handleUpgrade(request, socket, head, (ws) => {
-          peer.emit("connection", ws, request);
-        });
-      } else {
-        socket.destroy();
+  const wsServer = new WebSocketServer({
+    heartbeat: true,
+    heartbeatInterval: 3e4,
+    debug: false
+  });
+  wsServer.onConnection((connection) => {
+    connection.onMessage((message) => {
+      try {
+        const event = JSON.parse(message);
+        runtime.emit(event);
+      } catch {
       }
     });
-    peer.on("connection", (ws) => {
-      setupConnectionHandler(ws, connections, runtime);
-    });
-    setupBroadcasting(connections, runtime);
-    attachedToServer = true;
-    logger.info("WebSocket attached to existing HTTP server on /ws path");
+  });
+  runtime.onAny((event) => {
+    if (event.broadcastable === false) {
+      return;
+    }
+    wsServer.broadcast(JSON.stringify(event));
+  });
+  if (config.server) {
+    wsServer.attach(config.server, "/ws");
   }
   return {
     // Core API - delegate to runtime
@@ -294,56 +722,25 @@ async function createLocalAgentX(config) {
     emitCommand: (type, data) => runtime.emitCommand(type, data),
     // Server API
     async listen(port, host) {
-      if (attachedToServer) {
+      if (config.server) {
         throw new Error(
           "Cannot listen when attached to existing server. The server should call listen() instead."
         );
       }
-      if (peer) {
-        throw new Error("Server already listening");
-      }
-      const { WebSocketServer } = await import('ws');
-      peer = new WebSocketServer({ port, host: host ?? "0.0.0.0" });
-      peer.on("connection", (ws) => {
-        setupConnectionHandler(ws, connections, runtime);
-      });
-      setupBroadcasting(connections, runtime);
+      await wsServer.listen(port, host);
     },
     async close() {
-      if (!peer) return;
-      for (const ws of connections) {
-        ws.close();
-      }
-      connections.clear();
-      if (!attachedToServer) {
-        await new Promise((resolve) => {
-          peer.close(() => resolve());
-        });
-      }
-      peer = null;
+      await wsServer.close();
     },
     async dispose() {
-      if (peer) {
-        for (const ws of connections) {
-          ws.close();
-        }
-        connections.clear();
-        if (!attachedToServer) {
-          await new Promise((resolve) => {
-            peer.close(() => resolve());
-          });
-        }
-        peer = null;
-      }
+      await wsServer.dispose();
       await runtime.dispose();
     }
   };
 }
-var logger;
 var init_createLocalAgentX = __esm({
   "src/createLocalAgentX.ts"() {
-    init_dist();
-    logger = createLogger("agentx/createAgentX");
+    init_dist2();
   }
 });
 
@@ -365,25 +762,22 @@ async function createAgentX(config) {
   const { createLocalAgentX: createLocalAgentX2 } = await Promise.resolve().then(() => (init_createLocalAgentX(), createLocalAgentX_exports));
   return createLocalAgentX2(config ?? {});
 }
-var isBrowser = typeof window !== "undefined" && typeof window.WebSocket !== "undefined";
 async function createRemoteAgentX(serverUrl) {
-  const WebSocketImpl = isBrowser ? window.WebSocket : (await import('ws')).WebSocket;
-  const ws = new WebSocketImpl(serverUrl);
+  const { createWebSocketClient: createWebSocketClient2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports2));
+  const client = await createWebSocketClient2({
+    serverUrl,
+    autoReconnect: true,
+    minReconnectionDelay: 1e3,
+    maxReconnectionDelay: 1e4,
+    connectionTimeout: 4e3,
+    maxRetries: Infinity,
+    debug: false
+  });
   const handlers = /* @__PURE__ */ new Map();
   const pendingRequests = /* @__PURE__ */ new Map();
-  await new Promise((resolve, reject) => {
-    if (isBrowser) {
-      ws.onopen = () => resolve();
-      ws.onerror = () => reject(new Error("WebSocket connection failed"));
-    } else {
-      ws.on("open", () => resolve());
-      ws.on("error", (err) => reject(err));
-    }
-  });
-  const handleMessage = (data) => {
+  client.onMessage((message) => {
     try {
-      const text = isBrowser ? data.data : data.toString();
-      const event = JSON.parse(text);
+      const event = JSON.parse(message);
       remoteLogger.info("Received event", {
         type: event.type,
         category: event.category,
@@ -421,12 +815,13 @@ async function createRemoteAgentX(serverUrl) {
       }
     } catch {
     }
-  };
-  if (isBrowser) {
-    ws.onmessage = handleMessage;
-  } else {
-    ws.on("message", handleMessage);
-  }
+  });
+  client.onClose(() => {
+    remoteLogger.warn("WebSocket closed");
+  });
+  client.onError((error) => {
+    remoteLogger.error("WebSocket error", { error: error.message });
+  });
   function subscribe(type, handler) {
     if (!handlers.has(type)) {
       handlers.set(type, /* @__PURE__ */ new Set());
@@ -457,7 +852,7 @@ async function createRemoteAgentX(serverUrl) {
           category: "request",
           intent: "request"
         };
-        ws.send(JSON.stringify(event));
+        client.send(JSON.stringify(event));
       });
     },
     on(type, handler) {
@@ -475,7 +870,7 @@ async function createRemoteAgentX(serverUrl) {
         category: type.toString().endsWith("_response") ? "response" : "request",
         intent: type.toString().endsWith("_response") ? "result" : "request"
       };
-      ws.send(JSON.stringify(event));
+      client.send(JSON.stringify(event));
     },
     async listen() {
       throw new Error("Cannot listen in remote mode");
@@ -489,11 +884,7 @@ async function createRemoteAgentX(serverUrl) {
       }
       pendingRequests.clear();
       handlers.clear();
-      if (isBrowser) {
-        ws.close();
-      } else {
-        ws.close();
-      }
+      client.dispose();
     }
   };
 }