@agentxjs/ui 0.1.9 → 1.0.1

package/dist/index.js

@@ -172,7 +172,7 @@ __publicField$1(LoggerFactoryImpl$1, "config", {
 function createLogger$1(name2) {
   return LoggerFactoryImpl$1.getLogger(name2);
 }
-const logger$2 = createLogger$1("ui/useAgent");
+const logger$3 = createLogger$1("ui/useAgent");
 function useAgent(agentx, imageId, options = {}) {
   const { initialMessages = [], onSend, onError, onStatusChange } = options;
   const [messages, setMessages] = useState(initialMessages);
@@ -203,10 +203,10 @@ function useAgent(agentx, imageId, options = {}) {
             metadata: m.role === "error" && m.errorCode ? { errorCode: m.errorCode } : void 0
           }));
           setMessages(mappedMessages);
-          logger$2.debug("Loaded messages from storage", { imageId, count: mappedMessages.length });
+          logger$3.debug("Loaded messages from storage", { imageId, count: mappedMessages.length });
         }
       }).catch((err) => {
-        logger$2.error("Failed to load messages", { imageId, error: err });
+        logger$3.error("Failed to load messages", { imageId, error: err });
       });
     }
   }, [imageId, agentx]);
@@ -347,11 +347,11 @@ function useAgent(agentx, imageId, options = {}) {
         onStatusChange == null ? void 0 : onStatusChange("error");
       })
     );
-    logger$2.debug("Subscribed to agent events", { imageId });
+    logger$3.debug("Subscribed to agent events", { imageId });
     return () => {
       mountedRef.current = false;
       unsubscribes.forEach((unsub) => unsub());
-      logger$2.debug("Unsubscribed from agent events", { imageId });
+      logger$3.debug("Unsubscribed from agent events", { imageId });
     };
   }, [agentx, imageId, onError, onStatusChange]);
   const send = useCallback(
@@ -376,10 +376,10 @@ function useAgent(agentx, imageId, options = {}) {
         if (response.data.agentId) {
           agentIdRef.current = response.data.agentId;
           setAgentIdState(response.data.agentId);
-          logger$2.debug("Agent activated", { imageId, agentId: response.data.agentId });
+          logger$3.debug("Agent activated", { imageId, agentId: response.data.agentId });
         }
       } catch (error) {
-        logger$2.error("Failed to send message", { imageId, error });
+        logger$3.error("Failed to send message", { imageId, error });
         setStatus("error");
         onStatusChange == null ? void 0 : onStatusChange("error");
       }
@@ -389,7 +389,7 @@ function useAgent(agentx, imageId, options = {}) {
   const interrupt = useCallback(() => {
     if (!agentx || !imageId) return;
     agentx.request("agent_interrupt_request", { imageId }).catch((error) => {
-      logger$2.error("Failed to interrupt agent", { imageId, error });
+      logger$3.error("Failed to interrupt agent", { imageId, error });
     });
   }, [agentx, imageId]);
   const clearMessages = useCallback(() => {
@@ -412,18 +412,23 @@ function useAgent(agentx, imageId, options = {}) {
     agentId: agentIdState
   };
 }
+var __defProp2 = 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, all2) => {
+  for (var name2 in all2)
+    __defProp2(target, name2, { get: all2[name2], enumerable: true });
+};
 function createLogger(name2) {
   return LoggerFactoryImpl2.getLogger(name2);
 }
-var __defProp2, __defNormalProp2, __publicField2, _ConsoleLogger2, ConsoleLogger, externalFactory, LoggerFactoryImpl2;
+var __defProp22, __defNormalProp2, __publicField2, _ConsoleLogger2, ConsoleLogger, externalFactory, LoggerFactoryImpl2;
 var init_dist = __esm({
   "../common/dist/index.js"() {
-    __defProp2 = Object.defineProperty;
-    __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    __defProp22 = Object.defineProperty;
+    __defNormalProp2 = (obj, key, value) => key in obj ? __defProp22(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
     __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
     _ConsoleLogger2 = class _ConsoleLogger22 {
       constructor(name2, options = {}) {
@@ -589,31 +594,489 @@ var init_dist = __esm({
     });
   }
 });
+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, __defNormalProp22, __publicField22, logger$2, isBrowser, WebSocketClient, BrowserWebSocketClient;
+var init_chunk_63P5VUHB = __esm({
+  "../network/dist/chunk-63P5VUHB.js"() {
+    init_dist();
+    __defProp3 = Object.defineProperty;
+    __defNormalProp22 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    __publicField22 = (obj, key, value) => __defNormalProp22(obj, typeof key !== "symbol" ? key + "" : key, value);
+    logger$2 = createLogger("network/WebSocketClient");
+    isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window.WebSocket !== "undefined";
+    WebSocketClient = class {
+      constructor(options) {
+        __publicField22(this, "ws", null);
+        __publicField22(this, "serverUrl");
+        __publicField22(this, "messageHandlers", /* @__PURE__ */ new Set());
+        __publicField22(this, "openHandlers", /* @__PURE__ */ new Set());
+        __publicField22(this, "closeHandlers", /* @__PURE__ */ new Set());
+        __publicField22(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("./browser-Bab_T5G7.js").then((n) => n.b);
+        this.ws = new NodeWebSocket(this.serverUrl);
+        return new Promise((resolve, reject) => {
+          const onOpen = () => {
+            logger$2.info("WebSocket connected", { serverUrl: this.serverUrl });
+            for (const handler of this.openHandlers) {
+              handler();
+            }
+            resolve();
+          };
+          const onError = (err) => {
+            logger$2.error("WebSocket connection failed", {
+              serverUrl: this.serverUrl,
+              error: err == null ? void 0 : err.message
+            });
+            reject(err || new Error("WebSocket connection failed"));
+          };
+          this.ws.once("open", onOpen);
+          this.ws.once("error", onError);
+          this.ws.on("message", (data2) => {
+            const message = data2.toString();
+            for (const handler of this.messageHandlers) {
+              handler(message);
+            }
+          });
+          this.ws.on("close", () => {
+            logger$2.warn("WebSocket closed");
+            for (const handler of this.closeHandlers) {
+              handler();
+            }
+          });
+          this.ws.on("error", (err) => {
+            logger$2.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) {
+        __publicField22(this, "ws", null);
+        __publicField22(this, "serverUrl");
+        __publicField22(this, "options");
+        __publicField22(this, "messageHandlers", /* @__PURE__ */ new Set());
+        __publicField22(this, "openHandlers", /* @__PURE__ */ new Set());
+        __publicField22(this, "closeHandlers", /* @__PURE__ */ new Set());
+        __publicField22(this, "errorHandlers", /* @__PURE__ */ new Set());
+        __publicField22(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-mjs-CzX0YT0F.js")).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$2.info("WebSocket reconnected successfully", { serverUrl: this.serverUrl });
+            } else {
+              logger$2.info("WebSocket connected", { serverUrl: this.serverUrl });
+              this.hasConnectedBefore = true;
+            }
+            for (const handler of this.openHandlers) {
+              handler();
+            }
+            resolve();
+          };
+          const onError = (_event) => {
+            logger$2.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$2.info("WebSocket closed, attempting to reconnect...");
+            for (const handler of this.closeHandlers) {
+              handler();
+            }
+          }));
+          this.ws.addEventListener("error", ((_event) => {
+            logger$2.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();
+      }
+    };
+  }
+});
+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) {
+        __publicField22(this, "id");
+        __publicField22(this, "ws");
+        __publicField22(this, "messageHandlers", /* @__PURE__ */ new Set());
+        __publicField22(this, "closeHandlers", /* @__PURE__ */ new Set());
+        __publicField22(this, "errorHandlers", /* @__PURE__ */ new Set());
+        __publicField22(this, "heartbeatInterval");
+        __publicField22(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", (data2) => {
+          const message = data2.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 = {}) {
+        __publicField22(this, "wss", null);
+        __publicField22(this, "connections", /* @__PURE__ */ new Set());
+        __publicField22(this, "connectionHandlers", /* @__PURE__ */ new Set());
+        __publicField22(this, "options");
+        __publicField22(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("./browser-Bab_T5G7.js").then((n) => n.b);
+        this.wss = new WSS({ port, host });
+        this.wss.on("connection", (ws) => {
+          this.handleConnection(ws);
+        });
+        logger2.info("WebSocket server listening", { port, host });
+      }
+      attach(server, path2 = "/ws") {
+        if (this.wss) {
+          throw new Error("Server already initialized");
+        }
+        import("./browser-Bab_T5G7.js").then((n) => n.b).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 === path2) {
+              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: path2 });
+        });
+      }
+      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();
+      }
+    };
+  }
+});
 function isRemoteConfig(config) {
   return "serverUrl" in config && typeof config.serverUrl === "string";
 }
 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("./browser-Bab_T5G7.js").then((n) => n.b)).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 handlers2 = /* @__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 = (data2) => {
+  client.onMessage((message) => {
     var _a, _b, _c;
     try {
-      const text2 = isBrowser ? data2.data : data2.toString();
-      const event = JSON.parse(text2);
+      const event = JSON.parse(message);
       remoteLogger.info("Received event", {
         type: event.type,
         category: event.category,
@@ -651,12 +1114,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 (!handlers2.has(type)) {
       handlers2.set(type, /* @__PURE__ */ new Set());
@@ -688,7 +1152,7 @@ async function createRemoteAgentX(serverUrl) {
           category: "request",
           intent: "request"
         };
-        ws.send(JSON.stringify(event));
+        client.send(JSON.stringify(event));
       });
     },
     on(type, handler) {
@@ -706,7 +1170,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");
@@ -720,11 +1184,7 @@ async function createRemoteAgentX(serverUrl) {
       }
       pendingRequests.clear();
       handlers2.clear();
-      if (isBrowser) {
-        ws.close();
-      } else {
-        ws.close();
-      }
+      client.dispose();
     }
   };
 }