@noosphere/agent-core 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/index.cjs

@@ -304,54 +304,69 @@ var ContainerManager = class {
     this.containerPorts = /* @__PURE__ */ new Map();
     this.docker = new import_dockerode.default();
   }
-  async runContainer(container, input, timeout = 3e5) {
+  async runContainer(container, input, timeout = 3e5, connectionRetries = 5, connectionRetryDelayMs = 3e3) {
     const startTime = Date.now();
+    const port = container.port ? parseInt(container.port) : 8081;
+    const containerHost = process.env.DOCKER_NETWORK ? `noosphere-${container.name}` : "localhost";
+    const url = `http://${containerHost}:${port}/computation`;
+    let requestBody;
     try {
-      const port = container.port ? parseInt(container.port) : 8081;
-      const containerHost = process.env.DOCKER_NETWORK ? `noosphere-${container.name}` : "localhost";
-      const url = `http://${containerHost}:${port}/computation`;
-      let requestBody;
+      const parsedInput = JSON.parse(input);
+      requestBody = { input, ...parsedInput };
+    } catch {
+      requestBody = { input };
+    }
+    let lastError;
+    for (let attempt = 1; attempt <= connectionRetries; attempt++) {
       try {
-        const parsedInput = JSON.parse(input);
-        requestBody = { input, ...parsedInput };
-      } catch {
-        requestBody = { input };
-      }
-      const response = await import_axios.default.post(url, requestBody, {
-        timeout,
-        headers: {
-          "Content-Type": "application/json"
+        const response = await import_axios.default.post(url, requestBody, {
+          timeout,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        const executionTime2 = Date.now() - startTime;
+        let output;
+        if (typeof response.data === "string") {
+          output = response.data;
+        } else if (response.data.output !== void 0) {
+          output = typeof response.data.output === "string" ? response.data.output : JSON.stringify(response.data.output);
+        } else {
+          output = JSON.stringify(response.data);
         }
-      });
-      const executionTime = Date.now() - startTime;
-      let output;
-      if (typeof response.data === "string") {
-        output = response.data;
-      } else if (response.data.output !== void 0) {
-        output = typeof response.data.output === "string" ? response.data.output : JSON.stringify(response.data.output);
-      } else {
-        output = JSON.stringify(response.data);
-      }
-      return {
-        output,
-        exitCode: 0,
-        executionTime
-      };
-    } catch (error) {
-      const executionTime = Date.now() - startTime;
-      if (error.response) {
-        throw new Error(
-          `Container HTTP error ${error.response.status}: ${JSON.stringify(error.response.data)}`
-        );
-      } else if (error.code === "ECONNREFUSED") {
-        throw new Error(
-          `Cannot connect to container (port ${container.port || 8081}). Is it running?`
-        );
-      } else if (error.code === "ETIMEDOUT" || error.code === "ECONNABORTED") {
-        throw new Error(`Container execution timeout after ${timeout}ms`);
+        return {
+          output,
+          exitCode: 0,
+          executionTime: executionTime2
+        };
+      } catch (error) {
+        lastError = error;
+        if (error.code === "ECONNREFUSED") {
+          if (attempt < connectionRetries) {
+            console.log(`  \u23F3 Container not ready (attempt ${attempt}/${connectionRetries}), retrying in ${connectionRetryDelayMs / 1e3}s...`);
+            await this.sleep(connectionRetryDelayMs);
+            continue;
+          }
+        }
+        break;
       }
-      throw error;
     }
+    const executionTime = Date.now() - startTime;
+    if (lastError.response) {
+      throw new Error(
+        `Container HTTP error ${lastError.response.status}: ${JSON.stringify(lastError.response.data)}`
+      );
+    } else if (lastError.code === "ECONNREFUSED") {
+      throw new Error(
+        `Cannot connect to container (port ${container.port || 8081}) after ${connectionRetries} attempts. Is it running?`
+      );
+    } else if (lastError.code === "ETIMEDOUT" || lastError.code === "ECONNABORTED") {
+      throw new Error(`Container execution timeout after ${timeout}ms`);
+    }
+    throw lastError;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
   async collectContainerResult(dockerContainer, workDir, startTime) {
     try {
@@ -797,7 +812,13 @@ var SchedulerService = class extends import_events2.EventEmitter {
         try {
           currentInterval = BigInt(await this.router.getComputeSubscriptionInterval(sub.subscriptionId));
         } catch (error) {
-          console.warn(`  Could not get interval from router for subscription ${subId}:`, error.message);
+          const errorMessage = error.message || "";
+          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);
+            continue;
+          }
           const intervalsSinceActive = BigInt(currentBlockTime) - sub.activeAt;
           currentInterval = intervalsSinceActive / sub.intervalSeconds + 1n;
         }
@@ -1406,7 +1427,6 @@ var ConfigLoader = class {
 
 // src/NoosphereAgent.ts
 var NoosphereAgent = class _NoosphereAgent {
-  // Deduplication: track requests being processed
   constructor(options) {
     this.options = options;
     this.isRunning = false;
@@ -1464,6 +1484,12 @@ var NoosphereAgent = class _NoosphereAgent {
     if (!this.getContainer && (!this.containers || this.containers.size === 0)) {
       console.warn("\u26A0\uFE0F  No container source provided. Agent will not be able to execute requests.");
     }
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryIntervalMs = options.retryIntervalMs ?? 3e4;
+    this.containerTimeout = options.containerConfig?.timeout ?? 3e5;
+    this.containerConnectionRetries = options.containerConfig?.connectionRetries ?? 5;
+    this.containerConnectionRetryDelayMs = options.containerConfig?.connectionRetryDelayMs ?? 3e3;
+    this.healthCheckIntervalMs = options.healthCheckIntervalMs ?? 3e5;
   }
   /**
    * Initialize NoosphereAgent from config.json (RECOMMENDED)
@@ -1602,10 +1628,100 @@ var NoosphereAgent = class _NoosphereAgent {
         await this.handleRequest(data.requestStartedEvent);
       }
     });
+    if (this.options.getRetryableEvents && this.options.resetEventForRetry) {
+      this.startRetryTimer();
+    }
+    this.startHealthCheck();
     this.isRunning = true;
     console.log("\u2713 Noosphere Agent is running");
     console.log("Listening for requests...");
   }
+  /**
+   * Start the retry timer for failed requests
+   */
+  startRetryTimer() {
+    if (this.retryTimer) {
+      clearInterval(this.retryTimer);
+    }
+    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);
+  }
+  /**
+   * Start the health check timer for registry validation
+   */
+  startHealthCheck() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+    }
+    console.log(`\u{1F3E5} Health check enabled: check every ${this.healthCheckIntervalMs / 1e3}s`);
+    this.healthCheckTimer = setInterval(async () => {
+      await this.performHealthCheck();
+    }, this.healthCheckIntervalMs);
+  }
+  /**
+   * Perform health check - verify registry has containers and reload if necessary
+   */
+  async performHealthCheck() {
+    const stats = this.registryManager.getStats();
+    if (stats.totalContainers === 0) {
+      console.warn("\u26A0\uFE0F  Health check: 0 containers detected, attempting registry reload...");
+      try {
+        await this.registryManager.reload();
+        const newStats = this.registryManager.getStats();
+        if (newStats.totalContainers > 0) {
+          console.log(`\u2713 Health check: Registry recovered - ${newStats.totalContainers} containers loaded`);
+        } else {
+          console.error("\u274C Health check: Registry reload failed - still 0 containers");
+        }
+      } catch (error) {
+        console.error("\u274C Health check: Registry reload error:", error.message);
+      }
+    }
+  }
+  /**
+   * Process retryable failed events (with throttling to avoid rate limits)
+   */
+  async processRetries() {
+    if (!this.options.getRetryableEvents || !this.options.resetEventForRetry) {
+      return;
+    }
+    const retryableEvents = this.options.getRetryableEvents(this.maxRetries);
+    if (retryableEvents.length === 0) {
+      return;
+    }
+    const event = retryableEvents[0];
+    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)`);
+    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`);
+      return;
+    }
+    const retryEvent = {
+      requestId: event.requestId,
+      subscriptionId: BigInt(event.subscriptionId),
+      interval: event.interval,
+      containerId: event.containerId,
+      redundancy: 1,
+      useDeliveryInbox: false,
+      feeAmount: BigInt(0),
+      feeToken: "0x0000000000000000000000000000000000000000",
+      walletAddress: "0x0000000000000000000000000000000000000000",
+      verifier: "0x0000000000000000000000000000000000000000",
+      coordinator: this.config.coordinatorAddress,
+      blockNumber: 0
+    };
+    try {
+      await this.handleRequest(retryEvent);
+    } catch (error) {
+      console.log(`  \u274C Retry failed for ${event.requestId.slice(0, 10)}...: ${error.message}`);
+    }
+  }
   /**
    * Convert registry ContainerMetadata to agent-core ContainerMetadata
    */
@@ -1750,8 +1866,9 @@ var NoosphereAgent = class _NoosphereAgent {
       const result = await this.containerManager.runContainer(
         container,
         inputData,
-        3e5
-        // 5 min timeout
+        this.containerTimeout,
+        this.containerConnectionRetries,
+        this.containerConnectionRetryDelayMs
       );
       if (result.exitCode !== 0) {
         console.error(`  \u274C Container execution failed with exit code ${result.exitCode}`);
@@ -1842,6 +1959,14 @@ var NoosphereAgent = class _NoosphereAgent {
   }
   async stop() {
     console.log("Stopping Noosphere Agent...");
+    if (this.retryTimer) {
+      clearInterval(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = void 0;
+    }
     await this.eventMonitor.stop();
     this.scheduler.stop();
     await this.containerManager.cleanup();