agentxjs 0.1.9 → 1.0.1

package/dist/browser.cjs

@@ -1,19 +1,24 @@
 '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 });
+};
 
 // ../common/dist/index.js
 function createLogger(name) {
   return LoggerFactoryImpl.getLogger(name);
 }
-var __defProp, __defNormalProp, __publicField, _ConsoleLogger, ConsoleLogger, externalFactory, LoggerFactoryImpl;
+var __defProp2, __defNormalProp, __publicField, _ConsoleLogger, ConsoleLogger, externalFactory, LoggerFactoryImpl;
 var init_dist = __esm({
   "../common/dist/index.js"() {
-    __defProp = Object.defineProperty;
-    __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    __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 = {}) {
@@ -179,6 +184,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_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";
@@ -231,25 +701,22 @@ function isAgentEvent(event) {
 // src/createAgentX.ts
 init_dist();
 var remoteLogger = createLogger("agentx/RemoteClient");
-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_exports));
+  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,
@@ -287,12 +754,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());
@@ -323,7 +791,7 @@ async function createRemoteAgentX(serverUrl) {
           category: "request",
           intent: "request"
         };
-        ws.send(JSON.stringify(event));
+        client.send(JSON.stringify(event));
       });
     },
     on(type, handler) {
@@ -341,7 +809,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");
@@ -355,11 +823,7 @@ async function createRemoteAgentX(serverUrl) {
       }
       pendingRequests.clear();
       handlers.clear();
-      if (isBrowser) {
-        ws.close();
-      } else {
-        ws.close();
-      }
+      client.dispose();
     }
   };
 }