@noosphere/agent-core 0.2.0-alpha.2 → 0.2.0-alpha.3

package/dist/index.js

@@ -8,6 +8,12 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 // src/EventMonitor.ts
 import { EventEmitter } from "events";
 import { ethers } from "ethers";
+var DEFAULT_CONNECTION_CONFIG = {
+  wsConnectTimeoutMs: 1e4,
+  wsMaxConnectRetries: 3,
+  wsConnectRetryDelayMs: 5e3,
+  wsRecoveryIntervalMs: 6e4
+};
 var EventMonitor = class extends EventEmitter {
   constructor(config, routerAbi, coordinatorAbi, options) {
     super();
@@ -19,24 +25,115 @@ var EventMonitor = class extends EventEmitter {
     this.isReconnecting = false;
     this.heartbeatInterval = null;
     this.lastEventTime = Date.now();
+    // Connection state management
+    this.connectionState = "INIT";
+    this.wsRecoveryInterval = null;
+    this.pollingInterval = null;
     this.lastProcessedBlock = config.deploymentBlock || 0;
     this.useWebSocket = false;
     this.checkpointCallbacks = options;
+    this.connectionConfig = {
+      ...DEFAULT_CONNECTION_CONFIG,
+      ...options?.connectionConfig
+    };
+  }
+  /**
+   * Get current connection state
+   */
+  getConnectionState() {
+    return this.connectionState;
+  }
+  /**
+   * Get connection mode string for health API
+   */
+  getConnectionMode() {
+    switch (this.connectionState) {
+      case "WS_ACTIVE":
+        return "websocket";
+      case "HTTP_FALLBACK":
+        return "http_polling";
+      default:
+        return "connecting";
+    }
   }
   async connect() {
-    try {
-      if (this.config.wsRpcUrl) {
-        this.provider = new ethers.WebSocketProvider(this.config.wsRpcUrl);
-        this.useWebSocket = true;
-        console.log("\u2713 Connected via WebSocket (push-based events)");
-      } else {
-        throw new Error("WebSocket URL not provided");
+    const { wsMaxConnectRetries, wsConnectRetryDelayMs } = this.connectionConfig;
+    if (this.config.wsRpcUrl) {
+      this.connectionState = "WS_CONNECTING";
+      for (let attempt = 1; attempt <= wsMaxConnectRetries; attempt++) {
+        try {
+          console.log(`\u{1F50C} WebSocket connection attempt ${attempt}/${wsMaxConnectRetries}...`);
+          await this.connectWebSocketWithTimeout();
+          this.connectionState = "WS_ACTIVE";
+          this.useWebSocket = true;
+          console.log("\u2713 Connected via WebSocket (push-based events)");
+          this.initializeContracts();
+          return;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.warn(`\u26A0\uFE0F WebSocket attempt ${attempt}/${wsMaxConnectRetries} failed: ${errorMessage}`);
+          if (attempt < wsMaxConnectRetries) {
+            console.log(`   Retrying in ${wsConnectRetryDelayMs / 1e3}s...`);
+            await this.sleep(wsConnectRetryDelayMs);
+          }
+        }
+      }
+      console.warn(`\u26A0\uFE0F All ${wsMaxConnectRetries} WebSocket attempts failed, falling back to HTTP polling`);
+    } else {
+      console.log("\u2139\uFE0F No WebSocket URL provided, using HTTP polling");
+    }
+    await this.connectHttp();
+  }
+  /**
+   * Connect via WebSocket with timeout
+   */
+  async connectWebSocketWithTimeout() {
+    const { wsConnectTimeoutMs } = this.connectionConfig;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`WebSocket connection timeout after ${wsConnectTimeoutMs}ms`));
+      }, wsConnectTimeoutMs);
+      try {
+        const wsProvider = new ethers.WebSocketProvider(this.config.wsRpcUrl);
+        wsProvider.getBlockNumber().then(() => {
+          clearTimeout(timeout);
+          this.provider = wsProvider;
+          resolve();
+        }).catch((error) => {
+          clearTimeout(timeout);
+          wsProvider.destroy().catch(() => {
+          });
+          reject(error);
+        });
+      } catch (error) {
+        clearTimeout(timeout);
+        reject(error);
       }
+    });
+  }
+  /**
+   * Connect via HTTP (fallback mode)
+   */
+  async connectHttp() {
+    this.connectionState = "HTTP_FALLBACK";
+    this.useWebSocket = false;
+    this.provider = new ethers.JsonRpcProvider(this.config.rpcUrl);
+    try {
+      await this.provider.getBlockNumber();
+      console.log("\u2713 Connected via HTTP polling (fallback mode)");
     } catch (error) {
-      console.warn("WebSocket unavailable, falling back to HTTP polling");
-      this.provider = new ethers.JsonRpcProvider(this.config.rpcUrl);
-      this.useWebSocket = false;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`HTTP connection failed: ${errorMessage}`);
+    }
+    this.initializeContracts();
+    if (this.config.wsRpcUrl) {
+      this.startWsRecoveryLoop();
     }
+  }
+  /**
+   * Initialize contract instances
+   */
+  initializeContracts() {
     this.router = new ethers.Contract(this.config.routerAddress, this.routerAbi, this.provider);
     this.coordinator = new ethers.Contract(
       this.config.coordinatorAddress,
@@ -44,6 +141,63 @@ var EventMonitor = class extends EventEmitter {
       this.provider
     );
   }
+  /**
+   * Start WS recovery loop when in HTTP fallback mode
+   */
+  startWsRecoveryLoop() {
+    if (this.wsRecoveryInterval) {
+      clearInterval(this.wsRecoveryInterval);
+    }
+    const { wsRecoveryIntervalMs } = this.connectionConfig;
+    console.log(`\u{1F504} Starting WS recovery loop (every ${wsRecoveryIntervalMs / 1e3}s)`);
+    this.wsRecoveryInterval = setInterval(async () => {
+      if (this.connectionState !== "HTTP_FALLBACK") {
+        this.stopWsRecoveryLoop();
+        return;
+      }
+      console.log("\u{1F50C} Attempting WebSocket recovery...");
+      try {
+        await this.connectWebSocketWithTimeout();
+        console.log("\u2713 WebSocket connection recovered!");
+        this.stopPolling();
+        this.connectionState = "WS_ACTIVE";
+        this.useWebSocket = true;
+        this.initializeContracts();
+        await this.replayMissedEvents();
+        await this.startWebSocketListening();
+        this.stopWsRecoveryLoop();
+        this.emit("connectionRecovered", { mode: "websocket" });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.log(`   WS recovery failed: ${errorMessage}, will retry in ${wsRecoveryIntervalMs / 1e3}s`);
+      }
+    }, wsRecoveryIntervalMs);
+  }
+  /**
+   * Stop WS recovery loop
+   */
+  stopWsRecoveryLoop() {
+    if (this.wsRecoveryInterval) {
+      clearInterval(this.wsRecoveryInterval);
+      this.wsRecoveryInterval = null;
+      console.log("\u{1F504} WS recovery loop stopped");
+    }
+  }
+  /**
+   * Stop HTTP polling
+   */
+  stopPolling() {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = null;
+    }
+  }
+  /**
+   * Sleep helper
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
   async start() {
     if (this.checkpointCallbacks?.loadCheckpoint) {
       const checkpoint = this.checkpointCallbacks.loadCheckpoint();
@@ -115,7 +269,9 @@ var EventMonitor = class extends EventEmitter {
           const blockNumber = await this.provider.getBlockNumber();
           const timeSinceLastEvent = Date.now() - this.lastEventTime;
           if (timeSinceLastEvent > 18e4 && blockNumber > this.lastProcessedBlock + 5) {
-            console.log(`\u26A0\uFE0F No events for ${Math.round(timeSinceLastEvent / 1e3)}s, checking for missed events...`);
+            console.log(
+              `\u26A0\uFE0F No events for ${Math.round(timeSinceLastEvent / 1e3)}s, checking for missed events...`
+            );
             await this.replayMissedEvents();
           }
         }
@@ -129,7 +285,9 @@ var EventMonitor = class extends EventEmitter {
     try {
       const currentBlock = await this.provider.getBlockNumber();
       if (currentBlock > this.lastProcessedBlock) {
-        console.log(`\u{1F4E5} Replaying events from block ${this.lastProcessedBlock + 1} to ${currentBlock}`);
+        console.log(
+          `\u{1F4E5} Replaying events from block ${this.lastProcessedBlock + 1} to ${currentBlock}`
+        );
         await this.replayEvents(this.lastProcessedBlock + 1, currentBlock);
         this.lastEventTime = Date.now();
       }
@@ -140,6 +298,7 @@ var EventMonitor = class extends EventEmitter {
   handleDisconnect() {
     if (this.isReconnecting) return;
     this.isReconnecting = true;
+    this.connectionState = "WS_RECONNECTING";
     if (this.heartbeatInterval) {
       clearInterval(this.heartbeatInterval);
       this.heartbeatInterval = null;
@@ -150,9 +309,10 @@ var EventMonitor = class extends EventEmitter {
   }
   async startPolling() {
     console.log("Starting HTTP polling (fallback mode)...");
-    const pollingInterval = this.config.pollingInterval || 12e3;
+    this.stopPolling();
+    const pollingIntervalMs = this.config.pollingInterval || 12e3;
     let lastBlock = await this.provider.getBlockNumber();
-    setInterval(async () => {
+    this.pollingInterval = setInterval(async () => {
       try {
         const currentBlock = await this.provider.getBlockNumber();
         if (currentBlock > lastBlock) {
@@ -172,7 +332,7 @@ var EventMonitor = class extends EventEmitter {
       } catch (error) {
         console.error("Polling error:", error);
       }
-    }, pollingInterval);
+    }, pollingIntervalMs);
   }
   async processEvent(event) {
     const commitment = event.args.commitment;
@@ -195,16 +355,22 @@ var EventMonitor = class extends EventEmitter {
   async reconnect() {
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
       console.error("Max reconnection attempts reached. Falling back to HTTP polling.");
-      this.useWebSocket = false;
-      await this.connect();
+      if (this.provider instanceof ethers.WebSocketProvider) {
+        try {
+          await this.provider.destroy();
+        } catch {
+        }
+      }
+      await this.connectHttp();
       await this.startPolling();
+      this.reconnectAttempts = 0;
       return;
     }
     const backoff = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 6e4);
     console.log(
       `\u{1F504} Reconnecting in ${backoff}ms (attempt ${this.reconnectAttempts + 1}/${this.maxReconnectAttempts})`
     );
-    await new Promise((resolve) => setTimeout(resolve, backoff));
+    await this.sleep(backoff);
     try {
       if (this.coordinator) {
         this.coordinator.removeAllListeners();
@@ -215,14 +381,19 @@ var EventMonitor = class extends EventEmitter {
         } catch {
         }
       }
-      await this.connect();
+      await this.connectWebSocketWithTimeout();
+      this.connectionState = "WS_ACTIVE";
+      this.useWebSocket = true;
+      this.initializeContracts();
       await this.replayMissedEvents();
       await this.startWebSocketListening();
       console.log("\u2713 Reconnected successfully");
       this.reconnectAttempts = 0;
       this.lastEventTime = Date.now();
+      this.emit("connectionRecovered", { mode: "websocket" });
     } catch (error) {
-      console.error("Reconnection failed:", error);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`Reconnection failed: ${errorMessage}`);
       this.reconnectAttempts++;
       await this.reconnect();
     }
@@ -241,6 +412,8 @@ var EventMonitor = class extends EventEmitter {
       clearInterval(this.heartbeatInterval);
       this.heartbeatInterval = null;
     }
+    this.stopWsRecoveryLoop();
+    this.stopPolling();
     if (this.router) {
       this.router.removeAllListeners();
     }
@@ -250,6 +423,7 @@ var EventMonitor = class extends EventEmitter {
     if (this.provider instanceof ethers.WebSocketProvider) {
       await this.provider.destroy();
     }
+    this.connectionState = "INIT";
   }
 };
 
@@ -304,7 +478,9 @@ var ContainerManager = class {
         lastError = error;
         if (error.code === "ECONNREFUSED") {
           if (attempt < connectionRetries) {
-            console.log(`  \u23F3 Container not ready (attempt ${attempt}/${connectionRetries}), retrying in ${connectionRetryDelayMs / 1e3}s...`);
+            console.log(
+              `  \u23F3 Container not ready (attempt ${attempt}/${connectionRetries}), retrying in ${connectionRetryDelayMs / 1e3}s...`
+            );
             await this.sleep(connectionRetryDelayMs);
             continue;
           }
@@ -483,7 +659,10 @@ var ContainerManager = class {
       try {
         await this.startPersistentContainer(id, container);
       } catch (error) {
-        console.error(`  \u274C Failed to start ${container.name || container.image}:`, error.message);
+        console.error(
+          `  \u274C Failed to start ${container.name || container.image}:`,
+          error.message
+        );
       }
     });
     await Promise.all(pullAndStartPromises);
@@ -766,15 +945,22 @@ var SchedulerService = class extends EventEmitter2 {
       let currentInterval = 0n;
       try {
         if (sub.intervalSeconds <= 0n) {
-          console.warn(`  Skipping subscription ${subId}: invalid intervalSeconds (${sub.intervalSeconds})`);
+          console.warn(
+            `  Skipping subscription ${subId}: invalid intervalSeconds (${sub.intervalSeconds})`
+          );
           this.untrackSubscription(sub.subscriptionId);
           continue;
         }
         try {
-          currentInterval = BigInt(await this.router.getComputeSubscriptionInterval(sub.subscriptionId));
+          currentInterval = BigInt(
+            await this.router.getComputeSubscriptionInterval(sub.subscriptionId)
+          );
         } catch (error) {
           const errorMessage = error.message || "";
-          console.warn(`  Could not get interval from router for subscription ${subId}:`, errorMessage);
+          console.warn(
+            `  Could not get interval from router for subscription ${subId}:`,
+            errorMessage
+          );
           if (errorMessage.includes("SubscriptionNotFound")) {
             console.log(`  Subscription ${subId} not found (cancelled), untracking...`);
             this.untrackSubscription(sub.subscriptionId);
@@ -783,7 +969,9 @@ var SchedulerService = class extends EventEmitter2 {
           const intervalsSinceActive = BigInt(currentBlockTime) - sub.activeAt;
           currentInterval = intervalsSinceActive / sub.intervalSeconds + 1n;
         }
-        console.log(`  Subscription ${subId}: currentInterval=${currentInterval}, maxExecutions=${sub.maxExecutions}, activeAt=${sub.activeAt}`);
+        console.log(
+          `  Subscription ${subId}: currentInterval=${currentInterval}, maxExecutions=${sub.maxExecutions}, activeAt=${sub.activeAt}`
+        );
         if (!this.shouldProcess(sub, currentBlockTime)) {
           continue;
         }
@@ -810,12 +998,16 @@ var SchedulerService = class extends EventEmitter2 {
           return false;
         };
         if (containsError(error, "Panic due to OVERFLOW") || containsError(error, "arithmetic underflow or overflow")) {
-          console.log(`  Interval ${currentInterval} for subscription ${subId} appears to be already executed (overflow), marking as committed`);
+          console.log(
+            `  Interval ${currentInterval} for subscription ${subId} appears to be already executed (overflow), marking as committed`
+          );
           const commitmentKey = `${subId}:${currentInterval}`;
           this.addCommittedInterval(commitmentKey);
           sub.currentInterval = currentInterval + 1n;
         } else if (containsError(error, "0x3cdc51d3") || containsError(error, "NoNextInterval")) {
-          console.log(`  Subscription ${subId}: waiting for client to trigger interval 1 (NoNextInterval)`);
+          console.log(
+            `  Subscription ${subId}: waiting for client to trigger interval 1 (NoNextInterval)`
+          );
         } else if (containsError(error, "execution reverted") || containsError(error, "Transaction simulation failed")) {
           console.log(`  Subscription ${subId} appears to be cancelled or invalid, untracking...`);
           this.untrackSubscription(sub.subscriptionId);
@@ -829,13 +1021,17 @@ var SchedulerService = class extends EventEmitter2 {
   shouldProcess(sub, currentBlockTime) {
     const subId = sub.subscriptionId.toString();
     if (BigInt(currentBlockTime) < sub.activeAt) {
-      console.log(`    Skip: not active yet (currentTime=${currentBlockTime}, activeAt=${sub.activeAt})`);
+      console.log(
+        `    Skip: not active yet (currentTime=${currentBlockTime}, activeAt=${sub.activeAt})`
+      );
       return false;
     }
     const intervalsSinceActive = BigInt(currentBlockTime) - sub.activeAt;
     const currentInterval = intervalsSinceActive / sub.intervalSeconds + 1n;
     if (sub.maxExecutions > 0n && currentInterval > sub.maxExecutions) {
-      console.log(`    Subscription ${subId} completed (interval ${currentInterval} > maxExecutions ${sub.maxExecutions}), untracking...`);
+      console.log(
+        `    Subscription ${subId} completed (interval ${currentInterval} > maxExecutions ${sub.maxExecutions}), untracking...`
+      );
       this.untrackSubscription(sub.subscriptionId);
       return false;
     }
@@ -845,7 +1041,9 @@ var SchedulerService = class extends EventEmitter2 {
       return false;
     }
     if (sub.txAttempts >= this.config.maxRetryAttempts) {
-      console.log(`    Skip: max retry attempts reached (${sub.txAttempts}/${this.config.maxRetryAttempts})`);
+      console.log(
+        `    Skip: max retry attempts reached (${sub.txAttempts}/${this.config.maxRetryAttempts})`
+      );
       return false;
     }
     return true;
@@ -872,9 +1070,13 @@ var SchedulerService = class extends EventEmitter2 {
     const runKey = `${sub.subscriptionId}:${interval}`;
     try {
       console.log(`  Preparing interval ${interval} for subscription ${sub.subscriptionId}...`);
-      const currentIntervalNow = BigInt(await this.router.getComputeSubscriptionInterval(sub.subscriptionId));
+      const currentIntervalNow = BigInt(
+        await this.router.getComputeSubscriptionInterval(sub.subscriptionId)
+      );
       if (currentIntervalNow !== interval && currentIntervalNow !== interval - 1n) {
-        console.log(`  \u26A0\uFE0F  Interval changed: expected ${interval}, blockchain is at ${currentIntervalNow}. Skipping.`);
+        console.log(
+          `  \u26A0\uFE0F  Interval changed: expected ${interval}, blockchain is at ${currentIntervalNow}. Skipping.`
+        );
         return;
       }
       const tx = await this.coordinator.prepareNextInterval(
@@ -922,7 +1124,9 @@ var SchedulerService = class extends EventEmitter2 {
       const errorMessage = error.message || "";
       const isNoNextIntervalError = errorMessage.includes("0x3cdc51d3") || errorMessage.includes("NoNextInterval");
       if (isNoNextIntervalError) {
-        console.log(`  Subscription ${sub.subscriptionId}: NoNextInterval - waiting for client to trigger interval 1`);
+        console.log(
+          `  Subscription ${sub.subscriptionId}: NoNextInterval - waiting for client to trigger interval 1`
+        );
         sub.txAttempts = 0;
         return;
       }
@@ -1004,7 +1208,9 @@ var SchedulerService = class extends EventEmitter2 {
         }
         if (!this.isSubscriptionActive(sub, blockTime)) {
           if (sub.intervalSeconds > 0) {
-            console.log(`  Sub ${subscriptionId}: inactive (activeAt=${sub.activeAt}, now=${blockTime})`);
+            console.log(
+              `  Sub ${subscriptionId}: inactive (activeAt=${sub.activeAt}, now=${blockTime})`
+            );
           }
           skippedInactive++;
           continue;
@@ -1021,7 +1227,9 @@ var SchedulerService = class extends EventEmitter2 {
           }
         }
       }
-      console.log(`  Sync stats: ${newSubscriptions} tracked, ${skippedEmpty} empty, ${skippedInactive} inactive, ${skippedContainers} unsupported containers, ${skippedOnDemand} on-demand`);
+      console.log(
+        `  Sync stats: ${newSubscriptions} tracked, ${skippedEmpty} empty, ${skippedInactive} inactive, ${skippedContainers} unsupported containers, ${skippedOnDemand} on-demand`
+      );
       this.lastSyncedId = endId;
       if (newSubscriptions > 0) {
         console.log(`\u2713 Synced ${newSubscriptions} active subscriptions (ID ${startId} - ${endId})`);
@@ -1696,11 +1904,7 @@ var NoosphereAgent = class _NoosphereAgent {
       loadCheckpoint: options.loadCheckpoint,
       saveCheckpoint: options.saveCheckpoint
     });
-    this.router = new ethers5.Contract(
-      options.config.routerAddress,
-      routerAbi,
-      this.provider
-    );
+    this.router = new ethers5.Contract(options.config.routerAddress, routerAbi, this.provider);
     this.coordinator = new ethers5.Contract(
       options.config.coordinatorAddress,
       coordinatorAbi,
@@ -1855,23 +2059,28 @@ var NoosphereAgent = class _NoosphereAgent {
       console.warn("\u26A0\uFE0F  Failed to get SubscriptionBatchReader address:", error.message);
     }
     this.scheduler.start();
-    this.scheduler.on("commitment:success", async (data) => {
-      if (this.options.onCommitmentSuccess) {
-        this.options.onCommitmentSuccess({
-          subscriptionId: data.subscriptionId,
-          interval: data.interval,
-          txHash: data.txHash,
-          blockNumber: data.blockNumber,
-          gasUsed: data.gasUsed || "0",
-          gasPrice: data.gasPrice || "0",
-          gasCost: data.gasCost || "0"
-        });
-      }
-      if (data.requestStartedEvent) {
-        console.log(`  \u{1F4E5} Processing RequestStarted from prepare receipt (fallback for missed WebSocket)`);
-        await this.handleRequest(data.requestStartedEvent);
+    this.scheduler.on(
+      "commitment:success",
+      async (data) => {
+        if (this.options.onCommitmentSuccess) {
+          this.options.onCommitmentSuccess({
+            subscriptionId: data.subscriptionId,
+            interval: data.interval,
+            txHash: data.txHash,
+            blockNumber: data.blockNumber,
+            gasUsed: data.gasUsed || "0",
+            gasPrice: data.gasPrice || "0",
+            gasCost: data.gasCost || "0"
+          });
+        }
+        if (data.requestStartedEvent) {
+          console.log(
+            `  \u{1F4E5} Processing RequestStarted from prepare receipt (fallback for missed WebSocket)`
+          );
+          await this.handleRequest(data.requestStartedEvent);
+        }
       }
-    });
+    );
     if (this.options.getRetryableEvents && this.options.resetEventForRetry) {
       this.startRetryTimer();
     }
@@ -1887,7 +2096,9 @@ var NoosphereAgent = class _NoosphereAgent {
     if (this.retryTimer) {
       clearInterval(this.retryTimer);
     }
-    console.log(`\u{1F504} Retry mechanism enabled: max ${this.maxRetries} retries, check every ${this.retryIntervalMs / 1e3}s`);
+    console.log(
+      `\u{1F504} Retry mechanism enabled: max ${this.maxRetries} retries, check every ${this.retryIntervalMs / 1e3}s`
+    );
     this.retryTimer = setInterval(async () => {
       await this.processRetries();
     }, this.retryIntervalMs);
@@ -1915,7 +2126,9 @@ var NoosphereAgent = class _NoosphereAgent {
         await this.registryManager.reload();
         const newStats = this.registryManager.getStats();
         if (newStats.totalContainers > 0) {
-          console.log(`\u2713 Health check: Registry recovered - ${newStats.totalContainers} containers loaded`);
+          console.log(
+            `\u2713 Health check: Registry recovered - ${newStats.totalContainers} containers loaded`
+          );
         } else {
           console.error("\u274C Health check: Registry reload failed - still 0 containers");
         }
@@ -1939,11 +2152,15 @@ var NoosphereAgent = class _NoosphereAgent {
     if (this.processingRequests.has(event.requestId)) {
       return;
     }
-    console.log(`\u{1F504} Retrying request ${event.requestId.slice(0, 10)}... (attempt ${event.retryCount + 1}/${this.maxRetries}, ${retryableEvents.length} remaining)`);
+    console.log(
+      `\u{1F504} Retrying request ${event.requestId.slice(0, 10)}... (attempt ${event.retryCount + 1}/${this.maxRetries}, ${retryableEvents.length} remaining)`
+    );
     this.options.resetEventForRetry(event.requestId);
     const container = this.getContainerMetadata(event.containerId);
     if (!container) {
-      console.log(`  \u26A0\uFE0F Container ${event.containerId.slice(0, 10)}... no longer supported, skipping retry`);
+      console.log(
+        `  \u26A0\uFE0F Container ${event.containerId.slice(0, 10)}... no longer supported, skipping retry`
+      );
       return;
     }
     const retryEvent = {
@@ -1963,7 +2180,9 @@ var NoosphereAgent = class _NoosphereAgent {
     try {
       await this.handleRequest(retryEvent);
     } catch (error) {
-      console.log(`  \u274C Retry failed for ${event.requestId.slice(0, 10)}...: ${error.message}`);
+      console.log(
+        `  \u274C Retry failed for ${event.requestId.slice(0, 10)}...: ${error.message}`
+      );
     }
   }
   /**
@@ -2025,7 +2244,9 @@ var NoosphereAgent = class _NoosphereAgent {
     console.log(`  SubscriptionId: ${event.subscriptionId}`);
     console.log(`  Interval: ${event.interval}`);
     console.log(`  ContainerId: ${event.containerId.slice(0, 10)}...`);
-    console.log(`  \u{1F4E6} Container: ${container.name} (${container.image}:${container.tag || "latest"})`);
+    console.log(
+      `  \u{1F4E6} Container: ${container.name} (${container.image}:${container.tag || "latest"})`
+    );
     if (this.options.onRequestStarted) {
       this.options.onRequestStarted({
         requestId: event.requestId,
@@ -2041,13 +2262,18 @@ var NoosphereAgent = class _NoosphereAgent {
       });
     }
     try {
-      const currentInterval = await this.router.getComputeSubscriptionInterval(event.subscriptionId);
+      const currentInterval = await this.router.getComputeSubscriptionInterval(
+        event.subscriptionId
+      );
       const eventInterval = Number(event.interval);
       const isOneTimeExecution = currentInterval === 4294967295n;
       if (!isOneTimeExecution && currentInterval > eventInterval + 2) {
         console.log(`  \u23ED\uFE0F  Skipping old interval ${eventInterval} (current: ${currentInterval})`);
         if (this.options.onRequestSkipped) {
-          this.options.onRequestSkipped(event.requestId, `Old interval ${eventInterval} (current: ${currentInterval})`);
+          this.options.onRequestSkipped(
+            event.requestId,
+            `Old interval ${eventInterval} (current: ${currentInterval})`
+          );
         }
         this.processingRequests.delete(event.requestId);
         return;
@@ -2066,7 +2292,10 @@ var NoosphereAgent = class _NoosphereAgent {
       if (currentCount >= event.redundancy) {
         console.log(`  \u23ED\uFE0F  Already fulfilled (${currentCount}/${event.redundancy}), skipping`);
         if (this.options.onRequestSkipped) {
-          this.options.onRequestSkipped(event.requestId, `Already fulfilled (${currentCount}/${event.redundancy})`);
+          this.options.onRequestSkipped(
+            event.requestId,
+            `Already fulfilled (${currentCount}/${event.redundancy})`
+          );
         }
         this.processingRequests.delete(event.requestId);
         return;
@@ -2076,7 +2305,10 @@ var NoosphereAgent = class _NoosphereAgent {
       if (!clientAddress || clientAddress === "0x0000000000000000000000000000000000000000") {
         console.error(`  \u274C Invalid client address for subscription ${event.subscriptionId}`);
         if (this.options.onRequestFailed) {
-          this.options.onRequestFailed(event.requestId, `Invalid client address for subscription ${event.subscriptionId}`);
+          this.options.onRequestFailed(
+            event.requestId,
+            `Invalid client address for subscription ${event.subscriptionId}`
+          );
         }
         return;
       }
@@ -2128,7 +2360,10 @@ var NoosphereAgent = class _NoosphereAgent {
           const errorMessage = resolveError.message || String(resolveError);
           console.error(`  \u274C Failed to resolve PayloadData:`, resolveError);
           if (this.options.onRequestFailed) {
-            this.options.onRequestFailed(event.requestId, `Failed to resolve PayloadData: ${errorMessage}`);
+            this.options.onRequestFailed(
+              event.requestId,
+              `Failed to resolve PayloadData: ${errorMessage}`
+            );
           }
           return;
         }
@@ -2150,7 +2385,10 @@ var NoosphereAgent = class _NoosphereAgent {
         console.error(`  \u274C Container execution failed with exit code ${result.exitCode}`);
         console.error(`  \u{1F4C4} Container output:`, result.output);
         if (this.options.onRequestFailed) {
-          this.options.onRequestFailed(event.requestId, `Container execution failed with exit code ${result.exitCode}`);
+          this.options.onRequestFailed(
+            event.requestId,
+            `Container execution failed with exit code ${result.exitCode}`
+          );
         }
         return;
       }
@@ -2270,6 +2508,20 @@ var NoosphereAgent = class _NoosphereAgent {
   getScheduler() {
     return this.scheduler;
   }
+  /**
+   * Get current connection state
+   * @returns Connection state: 'INIT' | 'WS_CONNECTING' | 'WS_ACTIVE' | 'WS_RECONNECTING' | 'HTTP_FALLBACK'
+   */
+  getConnectionState() {
+    return this.eventMonitor.getConnectionState();
+  }
+  /**
+   * Get current connection mode
+   * @returns Connection mode: 'websocket' | 'http_polling' | 'connecting'
+   */
+  getConnectionMode() {
+    return this.eventMonitor.getConnectionMode();
+  }
 };
 
 // src/types/index.ts