@noosphere/agent-core 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1875 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/EventMonitor.ts
+import { EventEmitter } from "events";
+import { ethers } from "ethers";
+var EventMonitor = class extends EventEmitter {
+  constructor(config, routerAbi, coordinatorAbi, options) {
+    super();
+    this.config = config;
+    this.routerAbi = routerAbi;
+    this.coordinatorAbi = coordinatorAbi;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 10;
+    this.isReconnecting = false;
+    this.heartbeatInterval = null;
+    this.lastEventTime = Date.now();
+    this.lastProcessedBlock = config.deploymentBlock || 0;
+    this.useWebSocket = false;
+    this.checkpointCallbacks = options;
+  }
+  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");
+      }
+    } catch (error) {
+      console.warn("WebSocket unavailable, falling back to HTTP polling");
+      this.provider = new ethers.JsonRpcProvider(this.config.rpcUrl);
+      this.useWebSocket = false;
+    }
+    this.router = new ethers.Contract(this.config.routerAddress, this.routerAbi, this.provider);
+    this.coordinator = new ethers.Contract(
+      this.config.coordinatorAddress,
+      this.coordinatorAbi,
+      this.provider
+    );
+  }
+  async start() {
+    if (this.checkpointCallbacks?.loadCheckpoint) {
+      const checkpoint = this.checkpointCallbacks.loadCheckpoint();
+      if (checkpoint) {
+        this.lastProcessedBlock = checkpoint.blockNumber;
+      }
+    }
+    console.log(`Starting from block ${this.lastProcessedBlock}`);
+    await this.replayEvents(this.lastProcessedBlock, "latest");
+    if (this.useWebSocket) {
+      await this.startWebSocketListening();
+    } else {
+      await this.startPolling();
+    }
+  }
+  async replayEvents(fromBlock, toBlock) {
+    console.log(`Replaying events from block ${fromBlock} to ${toBlock}`);
+    const currentBlock = await this.provider.getBlockNumber();
+    const toBlockNumber = toBlock === "latest" ? currentBlock : Number(toBlock);
+    const chunkSize = 1e4;
+    for (let start = fromBlock; start <= toBlockNumber; start += chunkSize) {
+      const end = Math.min(start + chunkSize - 1, toBlockNumber);
+      const events = await this.coordinator.queryFilter(
+        this.coordinator.filters.RequestStarted(),
+        start,
+        end
+      );
+      for (const event of events) {
+        await this.processEvent(event);
+      }
+      if (events.length > 0) {
+        this.saveCheckpoint(end);
+      }
+    }
+    console.log(`Replayed events up to block ${toBlockNumber}`);
+  }
+  async startWebSocketListening() {
+    console.log("Starting WebSocket event listening...");
+    this.coordinator.on("RequestStarted", async (...args) => {
+      const event = args[args.length - 1];
+      this.lastEventTime = Date.now();
+      await this.processEvent(event);
+      const blockNumber = event.blockNumber;
+      if (blockNumber - this.lastProcessedBlock >= 10) {
+        this.saveCheckpoint(blockNumber);
+      }
+    });
+    if (this.provider instanceof ethers.WebSocketProvider) {
+      const wsProvider = this.provider;
+      const ws = wsProvider._websocket;
+      if (ws) {
+        ws.on("close", () => {
+          console.warn("\u26A0\uFE0F WebSocket connection closed");
+          this.handleDisconnect();
+        });
+        ws.on("error", (error) => {
+          console.error("\u26A0\uFE0F WebSocket error:", error.message);
+          this.handleDisconnect();
+        });
+      }
+    }
+    this.startHeartbeat();
+    console.log("\u2713 WebSocket event listener started");
+  }
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(async () => {
+      try {
+        if (this.provider instanceof ethers.WebSocketProvider) {
+          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...`);
+            await this.replayMissedEvents();
+          }
+        }
+      } catch (error) {
+        console.error("\u26A0\uFE0F Heartbeat failed, WebSocket may be disconnected");
+        this.handleDisconnect();
+      }
+    }, 12e4);
+  }
+  async replayMissedEvents() {
+    try {
+      const currentBlock = await this.provider.getBlockNumber();
+      if (currentBlock > this.lastProcessedBlock) {
+        console.log(`\u{1F4E5} Replaying events from block ${this.lastProcessedBlock + 1} to ${currentBlock}`);
+        await this.replayEvents(this.lastProcessedBlock + 1, currentBlock);
+        this.lastEventTime = Date.now();
+      }
+    } catch (error) {
+      console.error("Failed to replay missed events:", error);
+    }
+  }
+  handleDisconnect() {
+    if (this.isReconnecting) return;
+    this.isReconnecting = true;
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    this.reconnect().finally(() => {
+      this.isReconnecting = false;
+    });
+  }
+  async startPolling() {
+    console.log("Starting HTTP polling (fallback mode)...");
+    const pollingInterval = this.config.pollingInterval || 12e3;
+    let lastBlock = await this.provider.getBlockNumber();
+    setInterval(async () => {
+      try {
+        const currentBlock = await this.provider.getBlockNumber();
+        if (currentBlock > lastBlock) {
+          const events = await this.coordinator.queryFilter(
+            this.coordinator.filters.RequestStarted(),
+            lastBlock + 1,
+            currentBlock
+          );
+          for (const event of events) {
+            await this.processEvent(event);
+          }
+          if (events.length > 0) {
+            this.saveCheckpoint(currentBlock);
+          }
+          lastBlock = currentBlock;
+        }
+      } catch (error) {
+        console.error("Polling error:", error);
+      }
+    }, pollingInterval);
+  }
+  async processEvent(event) {
+    const commitment = event.args.commitment;
+    const requestStartedEvent = {
+      requestId: event.args.requestId,
+      subscriptionId: event.args.subscriptionId,
+      containerId: event.args.containerId,
+      interval: commitment.interval,
+      redundancy: commitment.redundancy,
+      useDeliveryInbox: commitment.useDeliveryInbox,
+      feeAmount: commitment.feeAmount,
+      feeToken: commitment.feeToken,
+      verifier: commitment.verifier,
+      coordinator: commitment.coordinator,
+      walletAddress: commitment.walletAddress,
+      blockNumber: event.blockNumber
+    };
+    this.emit("RequestStarted", requestStartedEvent);
+  }
+  async reconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("Max reconnection attempts reached. Falling back to HTTP polling.");
+      this.useWebSocket = false;
+      await this.connect();
+      await this.startPolling();
+      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));
+    try {
+      if (this.coordinator) {
+        this.coordinator.removeAllListeners();
+      }
+      if (this.provider instanceof ethers.WebSocketProvider) {
+        try {
+          await this.provider.destroy();
+        } catch {
+        }
+      }
+      await this.connect();
+      await this.replayMissedEvents();
+      await this.startWebSocketListening();
+      console.log("\u2713 Reconnected successfully");
+      this.reconnectAttempts = 0;
+      this.lastEventTime = Date.now();
+    } catch (error) {
+      console.error("Reconnection failed:", error);
+      this.reconnectAttempts++;
+      await this.reconnect();
+    }
+  }
+  saveCheckpoint(blockNumber) {
+    this.lastProcessedBlock = blockNumber;
+    if (this.checkpointCallbacks?.saveCheckpoint) {
+      this.checkpointCallbacks.saveCheckpoint({
+        blockNumber,
+        blockTimestamp: Date.now()
+      });
+    }
+  }
+  async stop() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.router) {
+      this.router.removeAllListeners();
+    }
+    if (this.coordinator) {
+      this.coordinator.removeAllListeners();
+    }
+    if (this.provider instanceof ethers.WebSocketProvider) {
+      await this.provider.destroy();
+    }
+  }
+};
+
+// src/ContainerManager.ts
+import Docker from "dockerode";
+import fs from "fs/promises";
+import path from "path";
+import axios from "axios";
+var ContainerManager = class {
+  constructor() {
+    this.runningContainers = /* @__PURE__ */ new Set();
+    this.persistentContainers = /* @__PURE__ */ new Map();
+    this.containerPorts = /* @__PURE__ */ new Map();
+    this.docker = new Docker();
+  }
+  async runContainer(container, input, timeout = 3e5) {
+    const startTime = Date.now();
+    try {
+      const port = container.port ? parseInt(container.port) : 8081;
+      const url = `http://localhost:${port}/computation`;
+      let requestBody;
+      try {
+        const parsedInput = JSON.parse(input);
+        requestBody = { input, ...parsedInput };
+      } catch {
+        requestBody = { input };
+      }
+      const response = await axios.post(url, requestBody, {
+        timeout,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      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`);
+      }
+      throw error;
+    }
+  }
+  async collectContainerResult(dockerContainer, workDir, startTime) {
+    try {
+      const inspectData = await dockerContainer.inspect();
+      const exitCode = inspectData.State.ExitCode || 0;
+      const outputPath = path.join(workDir, "output.json");
+      let output = "";
+      try {
+        output = await fs.readFile(outputPath, "utf-8");
+      } catch (error) {
+        const logs = await dockerContainer.logs({
+          stdout: true,
+          stderr: true
+        });
+        output = logs.toString();
+      }
+      const executionTime = Date.now() - startTime;
+      try {
+        await dockerContainer.remove({ force: true });
+      } catch (error) {
+      }
+      await fs.rm(workDir, { recursive: true, force: true });
+      return {
+        output,
+        exitCode,
+        executionTime
+      };
+    } catch (error) {
+      try {
+        await dockerContainer.remove({ force: true });
+      } catch {
+      }
+      await fs.rm(workDir, { recursive: true, force: true }).catch(() => {
+      });
+      throw error;
+    }
+  }
+  async pullImage(image, tag) {
+    const imageTag = `${image}:${tag}`;
+    try {
+      await this.docker.getImage(imageTag).inspect();
+      console.log(`Image ${imageTag} already exists`);
+    } catch {
+      console.log(`Pulling image ${imageTag}...`);
+      return new Promise((resolve, reject) => {
+        this.docker.pull(imageTag, (err, stream) => {
+          if (err) return reject(err);
+          this.docker.modem.followProgress(
+            stream,
+            (err2) => {
+              if (err2) return reject(err2);
+              console.log(`\u2713 Pulled image ${imageTag}`);
+              resolve();
+            },
+            (event) => {
+              if (event.status) {
+                console.log(`${event.status} ${event.progress || ""}`);
+              }
+            }
+          );
+        });
+      });
+    }
+  }
+  async waitForContainer(container) {
+    return new Promise((resolve, reject) => {
+      container.wait((err, data) => {
+        if (err) return reject(err);
+        resolve(data);
+      });
+    });
+  }
+  timeout(ms) {
+    return new Promise((resolve) => setTimeout(() => resolve(null), ms));
+  }
+  parseMemory(memory) {
+    const units = {
+      b: 1,
+      kb: 1024,
+      mb: 1024 * 1024,
+      gb: 1024 * 1024 * 1024
+    };
+    const match = memory.toLowerCase().match(/^(\d+)\s*(b|kb|mb|gb)$/);
+    if (!match) {
+      throw new Error(`Invalid memory format: ${memory}`);
+    }
+    const [, value, unit] = match;
+    return parseInt(value, 10) * units[unit];
+  }
+  async checkDockerAvailable() {
+    try {
+      await this.docker.ping();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getDockerInfo() {
+    return this.docker.info();
+  }
+  /**
+   * Cleanup all running containers
+   * Called when agent is shutting down
+   */
+  async cleanup() {
+    if (this.runningContainers.size === 0) {
+      return;
+    }
+    console.log(`\u{1F9F9} Cleaning up ${this.runningContainers.size} running containers...`);
+    const cleanupPromises = Array.from(this.runningContainers).map(async (container) => {
+      try {
+        const inspect = await container.inspect();
+        if (inspect.State.Running) {
+          console.log(`  Stopping container ${inspect.Id.slice(0, 12)}...`);
+          await container.stop({ t: 10 });
+          await container.remove({ force: true });
+        }
+      } catch (error) {
+        console.warn(`  Warning: Failed to cleanup container:`, error.message);
+      }
+    });
+    await Promise.all(cleanupPromises);
+    this.runningContainers.clear();
+    console.log("\u2713 Container cleanup completed");
+  }
+  /**
+   * Get number of running containers
+   */
+  getRunningContainerCount() {
+    return this.runningContainers.size;
+  }
+  /**
+   * Pre-pull container images and start persistent containers on startup
+   * This speeds up request handling by having containers ready
+   */
+  async prepareContainers(containers) {
+    if (containers.size === 0) {
+      console.log("No containers to prepare");
+      return;
+    }
+    console.log(`
+\u{1F680} Preparing ${containers.size} containers...`);
+    const pullAndStartPromises = Array.from(containers.entries()).map(async ([id, container]) => {
+      try {
+        const imageTag = `${container.image}:${container.tag || "latest"}`;
+        console.log(`  Pulling ${imageTag}...`);
+        await this.pullImage(container.image, container.tag || "latest");
+        console.log(`  \u2713 ${imageTag} ready`);
+        await this.startPersistentContainer(id, container);
+      } catch (error) {
+        console.error(`  \u274C Failed to prepare ${container.image}:`, error.message);
+      }
+    });
+    await Promise.all(pullAndStartPromises);
+    console.log("\u2713 All containers prepared\n");
+  }
+  /**
+   * Start a persistent container that stays running
+   */
+  async startPersistentContainer(containerId, metadata) {
+    const containerName = `noosphere-${containerId}`;
+    const imageTag = `${metadata.image}:${metadata.tag || "latest"}`;
+    try {
+      const existingContainer = this.docker.getContainer(containerName);
+      try {
+        const inspect = await existingContainer.inspect();
+        if (inspect.State.Running) {
+          console.log(`  \u2713 Container ${containerName} already running`);
+          this.persistentContainers.set(containerId, existingContainer);
+          return;
+        } else {
+          await existingContainer.start();
+          console.log(`  \u2713 Started existing container ${containerName}`);
+          this.persistentContainers.set(containerId, existingContainer);
+          return;
+        }
+      } catch (err) {
+      }
+    } catch (err) {
+    }
+    const createOptions = {
+      name: containerName,
+      Image: imageTag,
+      Tty: false,
+      AttachStdout: false,
+      AttachStderr: false,
+      ExposedPorts: metadata.port ? { [`${metadata.port}/tcp`]: {} } : void 0,
+      HostConfig: {
+        AutoRemove: false,
+        // Keep container for reuse
+        PortBindings: metadata.port ? {
+          [`${metadata.port}/tcp`]: [{ HostPort: metadata.port }]
+        } : void 0
+      },
+      Env: metadata.env ? Object.entries(metadata.env).map(([k, v]) => `${k}=${v}`) : void 0
+    };
+    if (metadata.requirements) {
+      const resources = {};
+      if (metadata.requirements.memory) {
+        resources.Memory = this.parseMemory(metadata.requirements.memory);
+      }
+      if (metadata.requirements.cpu) {
+        resources.NanoCpus = metadata.requirements.cpu * 1e9;
+      }
+      if (metadata.requirements.gpu) {
+        createOptions.HostConfig.DeviceRequests = [
+          {
+            Driver: "nvidia",
+            Count: -1,
+            Capabilities: [["gpu"]]
+          }
+        ];
+      }
+      if (Object.keys(resources).length > 0) {
+        createOptions.HostConfig = {
+          ...createOptions.HostConfig,
+          ...resources
+        };
+      }
+    }
+    const dockerContainer = await this.docker.createContainer(createOptions);
+    await dockerContainer.start();
+    this.persistentContainers.set(containerId, dockerContainer);
+    if (metadata.port) {
+      this.containerPorts.set(containerId, parseInt(metadata.port));
+    }
+    console.log(`  \u2713 Started persistent container ${containerName}`);
+  }
+  /**
+   * Stop and remove all persistent containers
+   */
+  async stopPersistentContainers() {
+    if (this.persistentContainers.size === 0) {
+      return;
+    }
+    console.log(`
+\u{1F6D1} Stopping ${this.persistentContainers.size} persistent containers...`);
+    const stopPromises = Array.from(this.persistentContainers.entries()).map(
+      async ([id, container]) => {
+        try {
+          const inspect = await container.inspect();
+          if (inspect.State.Running) {
+            console.log(`  Stopping ${inspect.Name}...`);
+            await container.stop({ t: 10 });
+          }
+          await container.remove({ force: true });
+          console.log(`  \u2713 Stopped ${inspect.Name}`);
+        } catch (error) {
+          console.warn(`  Warning: Failed to stop container ${id}:`, error.message);
+        }
+      }
+    );
+    await Promise.all(stopPromises);
+    this.persistentContainers.clear();
+    this.containerPorts.clear();
+    console.log("\u2713 All persistent containers stopped\n");
+  }
+};
+
+// src/NoosphereAgent.ts
+import { ethers as ethers4 } from "ethers";
+
+// src/SchedulerService.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { SubscriptionBatchReaderContract } from "@noosphere/contracts";
+var SchedulerService = class extends EventEmitter2 {
+  constructor(provider, router, coordinator, agentWallet, batchReaderAddress, config, getContainer) {
+    super();
+    this.provider = provider;
+    this.router = router;
+    this.coordinator = coordinator;
+    this.agentWallet = agentWallet;
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.committedIntervals = /* @__PURE__ */ new Set();
+    // subscriptionId:interval
+    this.pendingTxs = /* @__PURE__ */ new Map();
+    this.lastSyncedId = 0n;
+    this.config = {
+      cronIntervalMs: config?.cronIntervalMs ?? 6e4,
+      // 1 minute
+      maxRetryAttempts: config?.maxRetryAttempts ?? 3,
+      syncPeriodMs: config?.syncPeriodMs ?? 3e3,
+      // 3 seconds
+      loadCommittedIntervals: config?.loadCommittedIntervals,
+      saveCommittedInterval: config?.saveCommittedInterval
+    };
+    this.getContainer = getContainer;
+    if (batchReaderAddress) {
+      this.batchReader = new SubscriptionBatchReaderContract(batchReaderAddress, provider);
+      console.log(`\u2713 SubscriptionBatchReader configured: ${batchReaderAddress}`);
+    } else {
+      console.warn("\u26A0\uFE0F  SubscriptionBatchReader not configured - subscription sync disabled");
+    }
+  }
+  /**
+   * Start the scheduler service
+   */
+  start() {
+    console.log("\u{1F550} Starting Scheduler Service...");
+    console.log(`  Commitment generation interval: ${this.config.cronIntervalMs}ms`);
+    console.log(`  Sync period: ${this.config.syncPeriodMs}ms`);
+    if (this.config.loadCommittedIntervals) {
+      const loaded = this.config.loadCommittedIntervals();
+      for (const key of loaded) {
+        this.committedIntervals.add(key);
+      }
+      if (loaded.length > 0) {
+        console.log(`  Loaded ${loaded.length} committed intervals from storage`);
+      }
+    }
+    this.intervalTimer = setInterval(() => this.generateCommitments(), this.config.cronIntervalMs);
+    this.syncTimer = setInterval(() => this.syncSubscriptions(), this.config.syncPeriodMs);
+    console.log("\u2713 Scheduler Service started");
+  }
+  /**
+   * Stop the scheduler service
+   */
+  stop() {
+    if (this.intervalTimer) {
+      clearInterval(this.intervalTimer);
+      this.intervalTimer = void 0;
+    }
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = void 0;
+    }
+    console.log("\u2713 Scheduler Service stopped");
+  }
+  /**
+   * Track a new subscription
+   */
+  trackSubscription(subscription) {
+    const key = subscription.subscriptionId.toString();
+    if (this.subscriptions.has(key)) {
+      console.log(`  Subscription ${key} already tracked, updating...`);
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const elapsed = now - Number(subscription.activeAt);
+    const currentInterval = subscription.intervalSeconds > 0n ? BigInt(Math.max(1, Math.floor(elapsed / Number(subscription.intervalSeconds)) + 1)) : 1n;
+    this.subscriptions.set(key, {
+      ...subscription,
+      currentInterval,
+      lastProcessedAt: Date.now(),
+      txAttempts: 0
+    });
+    console.log(`\u2713 Tracking subscription ${key}`);
+    this.emit("subscription:tracked", subscription.subscriptionId);
+  }
+  /**
+   * Remove a subscription from tracking
+   */
+  untrackSubscription(subscriptionId) {
+    const key = subscriptionId.toString();
+    if (this.subscriptions.delete(key)) {
+      const prefix = `${key}:`;
+      let cleanedCount = 0;
+      for (const commitmentKey of this.committedIntervals) {
+        if (commitmentKey.startsWith(prefix)) {
+          this.committedIntervals.delete(commitmentKey);
+          cleanedCount++;
+        }
+      }
+      if (cleanedCount > 0) {
+        console.log(`  \u{1F9F9} Cleaned up ${cleanedCount} committed intervals for subscription ${key}`);
+      }
+      console.log(`\u2713 Stopped tracking subscription ${key}`);
+      this.emit("subscription:untracked", subscriptionId);
+    }
+  }
+  /**
+   * Mark an interval as committed (for RequestStarted events)
+   * Also persists to storage if callback is configured
+   */
+  markIntervalCommitted(subscriptionId, interval) {
+    const commitmentKey = `${subscriptionId}:${interval}`;
+    this.addCommittedInterval(commitmentKey);
+    console.log(`  \u2713 Marked interval ${interval} as committed for subscription ${subscriptionId}`);
+  }
+  /**
+   * Add to committed intervals set and persist to storage
+   */
+  addCommittedInterval(key) {
+    if (!this.committedIntervals.has(key)) {
+      this.committedIntervals.add(key);
+      if (this.config.saveCommittedInterval) {
+        this.config.saveCommittedInterval(key);
+      }
+    }
+  }
+  /**
+   * Main commitment generation loop (runs every cronIntervalMs)
+   * Equivalent to Java's CommitmentGenerationService.generateCommitment()
+   */
+  async generateCommitments() {
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      console.log(`
+\u{1F504} [${timestamp}] Starting commitment generation task...`);
+      this.pruneFailedTxs();
+      await this.processActiveSubscriptions();
+      const endTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+      console.log(`\u2713 [${endTimestamp}] Finished commitment generation task.
+`);
+    } catch (error) {
+      console.error("\u274C Error in commitment generation:", error);
+      this.emit("error", error);
+    }
+  }
+  /**
+   * Process all active subscriptions
+   */
+  async processActiveSubscriptions() {
+    const latestBlock = await this.provider.getBlock("latest");
+    if (!latestBlock) {
+      console.warn("  Could not fetch latest block, skipping this cycle");
+      return;
+    }
+    const currentBlockTime = latestBlock.timestamp;
+    if (this.subscriptions.size === 0) {
+      console.log("  No subscriptions to process");
+      return;
+    }
+    console.log(`  Processing ${this.subscriptions.size} subscription(s)...`);
+    for (const [subId, sub] of this.subscriptions.entries()) {
+      let currentInterval = 0n;
+      try {
+        if (sub.intervalSeconds <= 0n) {
+          console.warn(`  Skipping subscription ${subId}: invalid intervalSeconds (${sub.intervalSeconds})`);
+          this.untrackSubscription(sub.subscriptionId);
+          continue;
+        }
+        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 intervalsSinceActive = BigInt(currentBlockTime) - sub.activeAt;
+          currentInterval = intervalsSinceActive / sub.intervalSeconds + 1n;
+        }
+        console.log(`  Subscription ${subId}: currentInterval=${currentInterval}, maxExecutions=${sub.maxExecutions}, activeAt=${sub.activeAt}`);
+        if (!this.shouldProcess(sub, currentBlockTime)) {
+          continue;
+        }
+        const commitmentKey = `${subId}:${currentInterval}`;
+        if (this.committedIntervals.has(commitmentKey)) {
+          continue;
+        }
+        const hasCommitment = await this.hasRequestCommitments(sub.subscriptionId, currentInterval);
+        if (hasCommitment) {
+          this.addCommittedInterval(commitmentKey);
+          console.log(`  Subscription ${subId} interval ${currentInterval} already committed`);
+          continue;
+        }
+        await this.prepareNextInterval(sub, currentInterval);
+      } catch (error) {
+        const errorMessage = error.message;
+        console.error(`  Error processing subscription ${subId}:`, error);
+        const containsError = (ex, text) => {
+          let current = ex;
+          while (current) {
+            if (current.message?.includes(text)) return true;
+            current = current.cause;
+          }
+          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`);
+          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)`);
+        } 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);
+        }
+      }
+    }
+  }
+  /**
+   * Check if subscription should be processed
+   */
+  shouldProcess(sub, currentBlockTime) {
+    const subId = sub.subscriptionId.toString();
+    if (BigInt(currentBlockTime) < 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...`);
+      this.untrackSubscription(sub.subscriptionId);
+      return false;
+    }
+    const runKey = `${sub.subscriptionId}:${currentInterval}`;
+    if (this.pendingTxs.has(runKey)) {
+      console.log(`    Skip: pending transaction for interval ${currentInterval}`);
+      return false;
+    }
+    if (sub.txAttempts >= this.config.maxRetryAttempts) {
+      console.log(`    Skip: max retry attempts reached (${sub.txAttempts}/${this.config.maxRetryAttempts})`);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if interval already has commitments on-chain
+   */
+  async hasRequestCommitments(subscriptionId, interval) {
+    try {
+      const redundancy = await this.coordinator.redundancyCount(
+        this.getRequestId(subscriptionId, interval)
+      );
+      return redundancy > 0;
+    } catch (error) {
+      console.error("Error checking commitments:", error);
+      return false;
+    }
+  }
+  /**
+   * Prepare next interval by calling coordinator contract
+   * Equivalent to Java's CoordinatorService.prepareNextInterval()
+   */
+  async prepareNextInterval(sub, interval) {
+    const runKey = `${sub.subscriptionId}:${interval}`;
+    try {
+      console.log(`  Preparing interval ${interval} for subscription ${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.`);
+        return;
+      }
+      const tx = await this.coordinator.prepareNextInterval(
+        sub.subscriptionId,
+        interval,
+        this.agentWallet
+      );
+      this.pendingTxs.set(runKey, tx.hash);
+      sub.pendingTx = tx.hash;
+      console.log(`  \u{1F4E4} Transaction sent: ${tx.hash}`);
+      const receipt = await tx.wait();
+      if (receipt.status === 1) {
+        console.log(
+          `  \u2713 Interval ${interval} prepared successfully (block ${receipt.blockNumber})`
+        );
+        const commitmentKey = `${sub.subscriptionId}:${interval}`;
+        this.addCommittedInterval(commitmentKey);
+        sub.currentInterval = interval;
+        sub.lastProcessedAt = Date.now();
+        sub.txAttempts = 0;
+        sub.pendingTx = void 0;
+        this.pendingTxs.delete(runKey);
+        const requestStartedEvent = this.parseRequestStartedFromReceipt(receipt, sub);
+        const gasUsed = receipt.gasUsed;
+        const gasPrice = receipt.gasPrice ?? tx.gasPrice ?? 0n;
+        const gasCost = gasUsed * gasPrice;
+        this.emit("commitment:success", {
+          subscriptionId: sub.subscriptionId,
+          interval,
+          txHash: tx.hash,
+          blockNumber: receipt.blockNumber,
+          gasUsed: gasUsed.toString(),
+          gasPrice: gasPrice.toString(),
+          gasCost: gasCost.toString(),
+          requestStartedEvent
+          // Include parsed event for immediate processing
+        });
+      } else {
+        throw new Error(`Transaction failed with status ${receipt.status}`);
+      }
+    } catch (error) {
+      console.error(`  Failed to prepare interval for ${runKey}:`, error);
+      sub.pendingTx = void 0;
+      this.pendingTxs.delete(runKey);
+      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`);
+        sub.txAttempts = 0;
+        return;
+      }
+      sub.txAttempts++;
+      if (sub.txAttempts >= this.config.maxRetryAttempts) {
+        console.log(`  Max retry attempts reached for ${runKey}`);
+        this.emit("commitment:failed", {
+          subscriptionId: sub.subscriptionId,
+          interval,
+          error
+        });
+      }
+    }
+  }
+  /**
+   * Prune transactions that have failed
+   */
+  pruneFailedTxs() {
+    const fiveMinutesAgo = Date.now() - 5 * 60 * 1e3;
+    for (const [subId, sub] of this.subscriptions.entries()) {
+      if (sub.lastProcessedAt < fiveMinutesAgo && sub.pendingTx) {
+        console.log(`  Pruning stale transaction for subscription ${subId}`);
+        sub.pendingTx = void 0;
+        sub.txAttempts = 0;
+      }
+    }
+  }
+  /**
+   * Sync subscriptions (placeholder for blockchain event listening)
+   */
+  /**
+   * Sync subscriptions from blockchain
+   * Reads subscriptions in batches and tracks active ones
+   */
+  async syncSubscriptions() {
+    if (!this.batchReader) {
+      this.emit("sync:tick");
+      return;
+    }
+    try {
+      if (this.maxSubscriptionId === void 0) {
+        this.maxSubscriptionId = await this.router.getLastSubscriptionId();
+        console.log(`\u{1F4CA} Total subscriptions in registry: ${this.maxSubscriptionId}`);
+      }
+      if (this.lastSyncedId >= this.maxSubscriptionId) {
+        const latestMaxId = await this.router.getLastSubscriptionId();
+        if (latestMaxId > this.maxSubscriptionId) {
+          console.log(`\u{1F4CA} Found new subscriptions: ${latestMaxId} (was ${this.maxSubscriptionId})`);
+          this.maxSubscriptionId = latestMaxId;
+        } else {
+          this.emit("sync:tick");
+          return;
+        }
+      }
+      const maxSubId = this.maxSubscriptionId;
+      const currentBlock = await this.provider.getBlockNumber();
+      const block = await this.provider.getBlock(currentBlock);
+      const blockTime = block?.timestamp || Math.floor(Date.now() / 1e3);
+      const BATCH_SIZE = 100n;
+      const startId = this.lastSyncedId + 1n;
+      const endId = startId + BATCH_SIZE - 1n > maxSubId ? maxSubId : startId + BATCH_SIZE - 1n;
+      const subscriptions = await this.batchReader.getSubscriptions(startId, endId, currentBlock);
+      if (subscriptions.length === 0) {
+        this.emit("sync:tick");
+        return;
+      }
+      let newSubscriptions = 0;
+      let skippedContainers = 0;
+      let skippedInactive = 0;
+      let skippedEmpty = 0;
+      let skippedOnDemand = 0;
+      console.log(`  Syncing ${subscriptions.length} subscriptions (blockTime: ${blockTime})`);
+      for (let i = 0; i < subscriptions.length; i++) {
+        const sub = subscriptions[i];
+        const subscriptionId = startId + BigInt(i);
+        if (sub.containerId === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+          skippedEmpty++;
+          continue;
+        }
+        if (!this.isSubscriptionActive(sub, blockTime)) {
+          if (sub.intervalSeconds > 0) {
+            console.log(`  Sub ${subscriptionId}: inactive (activeAt=${sub.activeAt}, now=${blockTime})`);
+          }
+          skippedInactive++;
+          continue;
+        }
+        if (this.getContainer && !this.getContainer(sub.containerId)) {
+          skippedContainers++;
+          continue;
+        }
+        if (this.trackSubscriptionFromConfig(sub, subscriptionId)) {
+          newSubscriptions++;
+        } else {
+          if (sub.intervalSeconds <= 0) {
+            skippedOnDemand++;
+          }
+        }
+      }
+      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})`);
+      }
+      if (this.lastSyncedId >= maxSubId) {
+        console.log(`\u2713 Sync completed - processed all ${maxSubId} subscriptions`);
+      }
+      this.emit("sync:completed", {
+        subscriptions: this.subscriptions.size,
+        newSubscriptions
+      });
+    } catch (error) {
+      console.error("Error syncing subscriptions:", error);
+      this.emit("sync:error", error);
+    }
+  }
+  /**
+   * Check if subscription is currently active
+   */
+  isSubscriptionActive(sub, currentBlockTime) {
+    if (currentBlockTime < sub.activeAt) {
+      return false;
+    }
+    if (sub.maxExecutions > 0 && sub.intervalSeconds > 0) {
+      const elapsed = currentBlockTime - sub.activeAt;
+      const currentInterval = Math.floor(elapsed / sub.intervalSeconds);
+      if (currentInterval >= sub.maxExecutions) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Track subscription from ComputeSubscription config
+   * Returns true if subscription was tracked, false if skipped
+   */
+  trackSubscriptionFromConfig(sub, subscriptionId) {
+    if (sub.containerId === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+      return false;
+    }
+    if (sub.client === "0x0000000000000000000000000000000000000000") {
+      return false;
+    }
+    const key = subscriptionId.toString();
+    if (this.subscriptions.has(key)) {
+      return false;
+    }
+    if (sub.intervalSeconds <= 0) {
+      return false;
+    }
+    try {
+      const { ethers: ethers6 } = __require("ethers");
+      const containerIdStr = ethers6.decodeBytes32String(sub.containerId);
+      console.log(`  \u2713 Tracking subscription: ${containerIdStr}`);
+      console.log(`    Client: ${sub.client}`);
+      console.log(`    Interval: ${sub.intervalSeconds}s`);
+      console.log(`    Max Executions: ${sub.maxExecutions}`);
+    } catch (e) {
+      console.log(`  \u2713 Tracking subscription: ${sub.containerId}`);
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const elapsed = now - sub.activeAt;
+    const currentInterval = sub.intervalSeconds > 0 ? Math.max(1, Math.floor(elapsed / sub.intervalSeconds) + 1) : 1;
+    this.subscriptions.set(key, {
+      subscriptionId,
+      routeId: sub.routeId,
+      containerId: sub.containerId,
+      client: sub.client,
+      wallet: sub.wallet,
+      activeAt: BigInt(sub.activeAt),
+      intervalSeconds: BigInt(sub.intervalSeconds),
+      maxExecutions: Number.isFinite(sub.maxExecutions) ? BigInt(sub.maxExecutions) : 0n,
+      redundancy: sub.redundancy,
+      verifier: sub.verifier || void 0,
+      currentInterval: BigInt(currentInterval),
+      lastProcessedAt: Date.now(),
+      txAttempts: 0
+    });
+    return true;
+  }
+  /**
+   * Get request ID (hash of subscription ID and interval)
+   */
+  getRequestId(subscriptionId, interval) {
+    const ethers6 = __require("ethers");
+    const abiCoder = ethers6.AbiCoder.defaultAbiCoder();
+    return ethers6.keccak256(abiCoder.encode(["uint256", "uint256"], [subscriptionId, interval]));
+  }
+  /**
+   * Get scheduler statistics
+   */
+  getStats() {
+    const now = Math.floor(Date.now() / 1e3);
+    const activeCount = Array.from(this.subscriptions.values()).filter((sub) => {
+      if (BigInt(now) < sub.activeAt) {
+        return false;
+      }
+      if (sub.maxExecutions > 0n) {
+        const elapsed = BigInt(now) - sub.activeAt;
+        const currentInterval = elapsed / sub.intervalSeconds;
+        if (currentInterval >= sub.maxExecutions) {
+          return false;
+        }
+      }
+      return true;
+    }).length;
+    return {
+      totalSubscriptions: this.subscriptions.size,
+      activeSubscriptions: activeCount,
+      committedIntervals: this.committedIntervals.size,
+      pendingTransactions: this.pendingTxs.size
+    };
+  }
+  /**
+   * Get all tracked subscriptions
+   */
+  getSubscriptions() {
+    return Array.from(this.subscriptions.values());
+  }
+  /**
+   * Parse RequestStarted event from transaction receipt
+   * This allows the agent to process the event immediately without waiting for WebSocket
+   */
+  parseRequestStartedFromReceipt(receipt, sub) {
+    try {
+      for (const log of receipt.logs) {
+        try {
+          const parsed = this.coordinator.interface.parseLog({
+            topics: log.topics,
+            data: log.data
+          });
+          if (parsed && parsed.name === "RequestStarted") {
+            const commitment = parsed.args.commitment;
+            return {
+              requestId: parsed.args.requestId,
+              subscriptionId: parsed.args.subscriptionId,
+              containerId: parsed.args.containerId,
+              interval: Number(commitment.interval),
+              redundancy: Number(commitment.redundancy),
+              useDeliveryInbox: commitment.useDeliveryInbox,
+              feeAmount: commitment.feeAmount,
+              feeToken: commitment.feeToken,
+              verifier: commitment.verifier,
+              coordinator: commitment.coordinator,
+              walletAddress: commitment.walletAddress,
+              blockNumber: receipt.blockNumber
+            };
+          }
+        } catch {
+        }
+      }
+    } catch (error) {
+      console.warn("  \u26A0\uFE0F  Could not parse RequestStarted event from receipt:", error);
+    }
+    return null;
+  }
+};
+
+// src/NoosphereAgent.ts
+import { WalletManager, KeystoreManager } from "@noosphere/crypto";
+import { RegistryManager } from "@noosphere/registry";
+import { ABIs } from "@noosphere/contracts";
+
+// src/utils/CommitmentUtils.ts
+import { ethers as ethers2 } from "ethers";
+var CommitmentUtils = class {
+  /**
+   * Calculate commitment hash
+   * Matches the keccak256(abi.encode(commitment)) in Solidity
+   */
+  static hash(commitment) {
+    const encoded = ethers2.AbiCoder.defaultAbiCoder().encode(
+      [
+        "bytes32",
+        // requestId
+        "uint64",
+        // subscriptionId
+        "bytes32",
+        // containerId
+        "uint32",
+        // interval
+        "bool",
+        // useDeliveryInbox
+        "uint16",
+        // redundancy
+        "address",
+        // walletAddress
+        "uint256",
+        // feeAmount
+        "address",
+        // feeToken
+        "address",
+        // verifier
+        "address"
+        // coordinator
+      ],
+      [
+        commitment.requestId,
+        commitment.subscriptionId,
+        commitment.containerId,
+        commitment.interval,
+        commitment.useDeliveryInbox,
+        commitment.redundancy,
+        commitment.walletAddress,
+        commitment.feeAmount,
+        commitment.feeToken,
+        commitment.verifier,
+        commitment.coordinator
+      ]
+    );
+    return ethers2.keccak256(encoded);
+  }
+  /**
+   * Verify commitment hash matches expected value
+   */
+  static verify(commitment, expectedHash) {
+    const actualHash = this.hash(commitment);
+    return actualHash === expectedHash;
+  }
+  /**
+   * Encode commitment data for reportComputeResult
+   * Returns ABI-encoded commitment struct
+   */
+  static encode(commitment) {
+    return ethers2.AbiCoder.defaultAbiCoder().encode(
+      [
+        "bytes32",
+        // requestId
+        "uint64",
+        // subscriptionId
+        "bytes32",
+        // containerId
+        "uint32",
+        // interval
+        "bool",
+        // useDeliveryInbox
+        "uint16",
+        // redundancy
+        "address",
+        // walletAddress
+        "uint256",
+        // feeAmount
+        "address",
+        // feeToken
+        "address",
+        // verifier
+        "address"
+        // coordinator
+      ],
+      [
+        commitment.requestId,
+        commitment.subscriptionId,
+        commitment.containerId,
+        commitment.interval,
+        commitment.useDeliveryInbox,
+        commitment.redundancy,
+        commitment.walletAddress,
+        commitment.feeAmount,
+        commitment.feeToken,
+        commitment.verifier,
+        commitment.coordinator
+      ]
+    );
+  }
+  /**
+   * Create Commitment from RequestStartedEvent
+   */
+  static fromEvent(event, walletAddress) {
+    return {
+      requestId: event.requestId,
+      subscriptionId: event.subscriptionId,
+      containerId: event.containerId,
+      interval: event.interval,
+      redundancy: event.redundancy,
+      useDeliveryInbox: event.useDeliveryInbox || false,
+      feeToken: event.feeToken,
+      feeAmount: event.feeAmount,
+      walletAddress,
+      // Client wallet from subscription
+      verifier: event.verifier || ethers2.ZeroAddress,
+      coordinator: event.coordinator
+    };
+  }
+};
+
+// src/utils/ConfigLoader.ts
+import { readFileSync } from "fs";
+import { ethers as ethers3 } from "ethers";
+var ConfigLoader = class {
+  /**
+   * Load agent configuration from JSON file
+   */
+  static loadFromFile(configPath) {
+    try {
+      const configData = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(configData);
+      if (!config.chain || !config.chain.enabled) {
+        throw new Error("Chain configuration is required and must be enabled");
+      }
+      if (!config.chain.rpcUrl) {
+        throw new Error("Chain RPC URL is required");
+      }
+      if (!config.chain.routerAddress) {
+        throw new Error("Router address is required");
+      }
+      if (!config.containers || config.containers.length === 0) {
+        console.warn("\u26A0\uFE0F  No containers configured in config file");
+      }
+      return config;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Config file not found: ${configPath}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Convert ContainerConfig to ContainerMetadata format
+   */
+  static containerConfigToMetadata(containerConfig) {
+    const [imageName, tag] = containerConfig.image.includes(":") ? containerConfig.image.split(":") : [containerConfig.image, "latest"];
+    const name = imageName.split("/").pop() || containerConfig.id;
+    let payments;
+    if (containerConfig.acceptedPayments) {
+      const basePrice = Object.values(containerConfig.acceptedPayments)[0]?.toString() || "0";
+      payments = {
+        basePrice,
+        unit: "wei",
+        per: "execution"
+      };
+    }
+    return {
+      id: containerConfig.id,
+      name,
+      image: imageName,
+      tag,
+      port: containerConfig.port,
+      env: containerConfig.env,
+      verified: !!containerConfig.verifierAddress,
+      payments
+    };
+  }
+  /**
+   * Get all containers from config as ContainerMetadata array
+   */
+  static getContainersFromConfig(config) {
+    const containersMap = /* @__PURE__ */ new Map();
+    for (const containerConfig of config.containers) {
+      const metadata = this.containerConfigToMetadata(containerConfig);
+      const containerIdHash = ethers3.keccak256(
+        ethers3.AbiCoder.defaultAbiCoder().encode(["string"], [containerConfig.id])
+      );
+      containersMap.set(containerIdHash, metadata);
+    }
+    return containersMap;
+  }
+  /**
+   * Get container config by ID
+   */
+  static getContainerConfig(config, containerId) {
+    return config.containers.find((c) => c.id === containerId);
+  }
+};
+
+// src/NoosphereAgent.ts
+var NoosphereAgent = class _NoosphereAgent {
+  // Deduplication: track requests being processed
+  constructor(options) {
+    this.options = options;
+    this.isRunning = false;
+    this.processingRequests = /* @__PURE__ */ new Set();
+    this.config = options.config;
+    this.provider = new ethers4.JsonRpcProvider(options.config.rpcUrl);
+    const provider = this.provider;
+    const routerAbi = options.routerAbi || ABIs.Router;
+    const coordinatorAbi = options.coordinatorAbi || ABIs.Coordinator;
+    if (options.walletManager) {
+      this.walletManager = options.walletManager;
+    } else if (options.config.privateKey) {
+      this.walletManager = new WalletManager(options.config.privateKey, provider);
+    } else {
+      throw new Error(
+        "Either walletManager or config.privateKey must be provided. Recommended: Use NoosphereAgent.fromKeystore() for production."
+      );
+    }
+    this.containerManager = new ContainerManager();
+    this.registryManager = new RegistryManager({
+      autoSync: true,
+      // Enable automatic sync with remote registry
+      cacheTTL: 36e5
+      // 1 hour cache
+    });
+    this.eventMonitor = new EventMonitor(options.config, routerAbi, coordinatorAbi, {
+      loadCheckpoint: options.loadCheckpoint,
+      saveCheckpoint: options.saveCheckpoint
+    });
+    this.router = new ethers4.Contract(
+      options.config.routerAddress,
+      routerAbi,
+      this.provider
+    );
+    this.coordinator = new ethers4.Contract(
+      options.config.coordinatorAddress,
+      coordinatorAbi,
+      this.walletManager.getWallet()
+    );
+    this.getContainer = options.getContainer;
+    this.containers = options.containers;
+    this.scheduler = new SchedulerService(
+      provider,
+      this.router,
+      this.coordinator,
+      this.walletManager.getAddress(),
+      void 0,
+      // batchReaderAddress (set later)
+      void 0,
+      // config (set later)
+      this.getContainer
+      // Pass container filter
+    );
+    this.paymentWallet = options.paymentWallet;
+    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.");
+    }
+  }
+  /**
+   * Initialize NoosphereAgent from config.json (RECOMMENDED)
+   * This loads all configuration including containers from a config file
+   *
+   * @param configPath - Path to config.json file
+   * @param routerAbi - Router contract ABI (optional - defaults to ABIs.Router)
+   * @param coordinatorAbi - Coordinator contract ABI (optional - defaults to ABIs.Coordinator)
+   * @returns Initialized NoosphereAgent
+   */
+  static async fromConfig(configPath, routerAbi, coordinatorAbi) {
+    const fullConfig = ConfigLoader.loadFromFile(configPath);
+    const keystorePath = fullConfig.chain.wallet.keystore?.path;
+    const password = fullConfig.chain.wallet.keystore?.password;
+    if (!keystorePath || !password) {
+      throw new Error("Keystore path and password are required in config.chain.wallet.keystore");
+    }
+    const containers = ConfigLoader.getContainersFromConfig(fullConfig);
+    console.log(`\u{1F4E6} Loaded ${containers.size} containers from config:`);
+    for (const [id, container] of containers.entries()) {
+      console.log(`  - ${id}: ${container.image}:${container.tag || "latest"}`);
+    }
+    const provider = new ethers4.JsonRpcProvider(fullConfig.chain.rpcUrl);
+    const keystoreManager = new KeystoreManager(keystorePath, password);
+    await keystoreManager.load();
+    const walletManager = await WalletManager.fromKeystoreManager(keystoreManager, provider);
+    const agentConfig = {
+      rpcUrl: fullConfig.chain.rpcUrl,
+      wsRpcUrl: fullConfig.chain.wsRpcUrl,
+      routerAddress: fullConfig.chain.routerAddress,
+      coordinatorAddress: fullConfig.chain.coordinatorAddress || fullConfig.chain.routerAddress,
+      deploymentBlock: fullConfig.chain.deploymentBlock,
+      pollingInterval: fullConfig.chain.processingInterval
+    };
+    const paymentWallet = fullConfig.chain.wallet.paymentAddress;
+    return new _NoosphereAgent({
+      config: agentConfig,
+      routerAbi,
+      coordinatorAbi,
+      walletManager,
+      containers,
+      paymentWallet
+    });
+  }
+  /**
+   * Initialize NoosphereAgent from keystore (RECOMMENDED)
+   * This is the secure way to initialize an agent in production
+   *
+   * @param keystorePath - Path to keystore file
+   * @param password - Keystore password
+   * @param options - Agent configuration options
+   * @returns Initialized NoosphereAgent
+   */
+  static async fromKeystore(keystorePath, password, options) {
+    const provider = new ethers4.JsonRpcProvider(options.config.rpcUrl);
+    const keystoreManager = new KeystoreManager(keystorePath, password);
+    await keystoreManager.load();
+    const walletManager = await WalletManager.fromKeystoreManager(keystoreManager, provider);
+    return new _NoosphereAgent({
+      ...options,
+      walletManager
+    });
+  }
+  async start() {
+    console.log("Starting Noosphere Agent...");
+    console.log("\u{1F4CB} Loading container registry...");
+    await this.registryManager.load();
+    const stats = this.registryManager.getStats();
+    console.log(
+      `\u2713 Registry loaded: ${stats.totalContainers} containers, ${stats.totalVerifiers} verifiers`
+    );
+    const dockerAvailable = await this.containerManager.checkDockerAvailable();
+    if (!dockerAvailable) {
+      throw new Error("Docker is not available. Please ensure Docker daemon is running.");
+    }
+    const address = this.walletManager.getAddress();
+    const balance = await this.walletManager.getBalance();
+    console.log(`Agent wallet: ${address}`);
+    console.log(`Balance: ${ethers4.formatEther(balance)} ETH`);
+    if (balance === 0n) {
+      console.warn("\u26A0\uFE0F  Warning: Wallet has zero balance. Agent needs ETH for gas fees.");
+    }
+    if (this.containers && this.containers.size > 0) {
+      console.log(`
+\u{1F680} Preparing ${this.containers.size} containers...`);
+      await this.containerManager.prepareContainers(this.containers);
+    }
+    await this.eventMonitor.connect();
+    this.eventMonitor.on("RequestStarted", async (event) => {
+      await this.handleRequest(event);
+    });
+    await this.eventMonitor.start();
+    try {
+      const batchReaderAddress = await this.coordinator.getSubscriptionBatchReader();
+      if (batchReaderAddress && batchReaderAddress !== "0x0000000000000000000000000000000000000000") {
+        console.log(`\u2713 SubscriptionBatchReader found: ${batchReaderAddress}`);
+        this.scheduler.stop();
+        this.scheduler = new SchedulerService(
+          this.provider,
+          this.router,
+          this.coordinator,
+          this.walletManager.getAddress(),
+          batchReaderAddress,
+          this.options.schedulerConfig || {
+            cronIntervalMs: 6e4,
+            // 1 minute (default)
+            syncPeriodMs: 3e3,
+            // 3 seconds (default)
+            maxRetryAttempts: 3
+            // 3 retries (default)
+          },
+          this.getContainer
+          // Pass container filter
+        );
+      } else {
+        console.warn("\u26A0\uFE0F  SubscriptionBatchReader not available - subscription sync disabled");
+      }
+    } catch (error) {
+      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.isRunning = true;
+    console.log("\u2713 Noosphere Agent is running");
+    console.log("Listening for requests...");
+  }
+  /**
+   * Convert registry ContainerMetadata to agent-core ContainerMetadata
+   */
+  convertRegistryContainer(registryContainer) {
+    const [image, tag] = registryContainer.imageName.split(":");
+    return {
+      id: registryContainer.id,
+      name: registryContainer.name,
+      image,
+      tag: tag || "latest",
+      port: registryContainer.port?.toString(),
+      env: registryContainer.env,
+      requirements: registryContainer.requirements,
+      payments: registryContainer.payments ? {
+        basePrice: registryContainer.payments.basePrice,
+        unit: registryContainer.payments.token,
+        per: registryContainer.payments.per
+      } : void 0,
+      verified: registryContainer.verified
+    };
+  }
+  async handleRequest(event) {
+    const requestIdShort = event.requestId.slice(0, 10);
+    if (this.processingRequests.has(event.requestId)) {
+      console.log(`  \u23ED\uFE0F  Request ${requestIdShort}... already being processed, skipping duplicate`);
+      return;
+    }
+    if (this.options.isRequestProcessed && this.options.isRequestProcessed(event.requestId)) {
+      console.log(`  \u23ED\uFE0F  Request ${requestIdShort}... already processed, skipping`);
+      return;
+    }
+    this.processingRequests.add(event.requestId);
+    console.log(`
+[${(/* @__PURE__ */ new Date()).toISOString()}] RequestStarted: ${requestIdShort}...`);
+    console.log(`  SubscriptionId: ${event.subscriptionId}`);
+    console.log(`  Interval: ${event.interval}`);
+    console.log(`  ContainerId: ${event.containerId.slice(0, 10)}...`);
+    if (this.options.onRequestStarted) {
+      this.options.onRequestStarted({
+        requestId: event.requestId,
+        subscriptionId: Number(event.subscriptionId),
+        interval: Number(event.interval),
+        containerId: event.containerId,
+        redundancy: event.redundancy,
+        feeAmount: event.feeAmount.toString(),
+        feeToken: event.feeToken,
+        verifier: event.verifier,
+        walletAddress: event.walletAddress,
+        blockNumber: event.blockNumber
+      });
+    }
+    try {
+      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.processingRequests.delete(event.requestId);
+        return;
+      }
+    } catch (error) {
+      console.warn(`  Could not verify interval currency:`, error.message);
+    }
+    this.scheduler.markIntervalCommitted(BigInt(event.subscriptionId), BigInt(event.interval));
+    try {
+      await this.waitForPriority(event);
+      if (this.options.onRequestProcessing) {
+        this.options.onRequestProcessing(event.requestId);
+      }
+      const currentCount = await this.coordinator.redundancyCount(event.requestId);
+      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.processingRequests.delete(event.requestId);
+        return;
+      }
+      let container;
+      if (this.getContainer) {
+        container = this.getContainer(event.containerId);
+        if (container) {
+          console.log(`  \u{1F4E6} Container found via callback: ${container.name}`);
+        }
+      }
+      if (!container) {
+        const registryContainer = this.registryManager.getContainer(event.containerId);
+        if (registryContainer) {
+          console.log(`  \u{1F4CB} Container found in registry: ${registryContainer.name}`);
+          container = this.convertRegistryContainer(registryContainer);
+        }
+      }
+      if (!container && this.containers) {
+        container = this.containers.get(event.containerId);
+        if (container) {
+          console.log(`  \u{1F4E6} Container found in config: ${container.name}`);
+        }
+      }
+      if (!container) {
+        console.error(`  \u274C Container not found: ${event.containerId}`);
+        console.error(`  \u{1F4A1} Try adding it to the registry or config file`);
+        if (this.options.onRequestSkipped) {
+          this.options.onRequestSkipped(event.requestId, `Container not found: ${event.containerId}`);
+        }
+        return;
+      }
+      console.log(
+        `  \u{1F4E6} Using container: ${container.name} (${container.image}:${container.tag || "latest"})`
+      );
+      const subscription = await this.router.getComputeSubscription(event.subscriptionId);
+      const clientAddress = subscription.client;
+      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}`);
+        }
+        return;
+      }
+      console.log(`  \u{1F4DE} Fetching inputs from client: ${clientAddress.slice(0, 10)}...`);
+      const clientAbi = [
+        "function getComputeInputs(uint64 subscriptionId, uint32 interval, uint32 timestamp, address caller) external view returns (bytes memory)"
+      ];
+      const client = new ethers4.Contract(clientAddress, clientAbi, this.provider);
+      const timestamp = Math.floor(Date.now() / 1e3);
+      let inputBytes;
+      try {
+        inputBytes = await client.getComputeInputs(
+          event.subscriptionId,
+          event.interval,
+          timestamp,
+          this.walletManager.getAddress()
+        );
+      } catch (error) {
+        const errorMessage = error.message || String(error);
+        console.error(`  \u274C Failed to get inputs from client:`, error);
+        if (this.options.onRequestFailed) {
+          this.options.onRequestFailed(event.requestId, `Failed to get inputs: ${errorMessage}`);
+        }
+        return;
+      }
+      const inputData = ethers4.toUtf8String(inputBytes);
+      console.log(
+        `  \u{1F4E5} Inputs received: ${inputData.substring(0, 100)}${inputData.length > 100 ? "..." : ""}`
+      );
+      console.log(`  \u2699\uFE0F  Executing...`);
+      const result = await this.containerManager.runContainer(
+        container,
+        inputData,
+        3e5
+        // 5 min timeout
+      );
+      if (result.exitCode !== 0) {
+        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}`);
+        }
+        return;
+      }
+      console.log(`  \u2713 Execution completed in ${result.executionTime}ms`);
+      console.log(`  \u{1F4E4} Submitting result...`);
+      const input = inputData;
+      const output = result.output;
+      const proof = event.verifier ? result.output : "";
+      const subscriptionWallet = event.walletAddress;
+      const commitment = CommitmentUtils.fromEvent(event, subscriptionWallet);
+      const commitmentData = CommitmentUtils.encode(commitment);
+      const nodeWallet = this.paymentWallet || this.walletManager.getAddress();
+      const tx = await this.coordinator.reportComputeResult(
+        event.interval,
+        ethers4.toUtf8Bytes(input),
+        ethers4.toUtf8Bytes(output),
+        ethers4.toUtf8Bytes(proof),
+        commitmentData,
+        nodeWallet
+      );
+      console.log(`  \u{1F4E4} Transaction sent: ${tx.hash}`);
+      const receipt = await tx.wait();
+      if (receipt.status === 1) {
+        console.log(`  \u2713 Result delivered successfully (block ${receipt.blockNumber})`);
+        console.log(`  \u{1F4B0} Fee earned: ${ethers4.formatEther(event.feeAmount)} ETH`);
+        if (this.options.onComputeDelivered) {
+          this.options.onComputeDelivered({
+            requestId: event.requestId,
+            subscriptionId: Number(event.subscriptionId),
+            interval: Number(event.interval),
+            containerId: event.containerId,
+            redundancy: event.redundancy,
+            feeAmount: event.feeAmount.toString(),
+            feeToken: event.feeToken,
+            input,
+            output,
+            txHash: tx.hash,
+            blockNumber: receipt.blockNumber,
+            gasUsed: receipt.gasUsed,
+            gasPrice: receipt.gasPrice || tx.gasPrice || 0n
+          });
+        }
+      } else {
+        throw new Error(`Delivery transaction failed with status ${receipt.status}`);
+      }
+    } catch (error) {
+      const errorMessage = error.message || String(error);
+      const errorCode = error.code;
+      if (errorCode === "NONCE_EXPIRED" || errorMessage.includes("nonce has already been used") || errorMessage.includes("nonce too low")) {
+        console.log(`  \u26A0\uFE0F  Nonce expired (likely already processed by another handler)`);
+        return;
+      }
+      console.error(`  \u274C Error processing request:`, error);
+      if (this.options.onRequestFailed) {
+        this.options.onRequestFailed(event.requestId, errorMessage);
+      }
+    } finally {
+      this.processingRequests.delete(event.requestId);
+    }
+  }
+  /**
+   * Self-coordination: Calculate priority and wait
+   */
+  async waitForPriority(event) {
+    const priority = this.calculatePriority(event.requestId);
+    const maxDelay = event.redundancy === 1 ? 1e3 : 200;
+    const delay = Math.floor(priority / 4294967295 * maxDelay);
+    if (delay > 0) {
+      console.log(
+        `  \u23F1\uFE0F  Priority wait: ${delay}ms (priority: 0x${priority.toString(16).slice(0, 8)})`
+      );
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  /**
+   * Calculate deterministic priority for this agent and request
+   */
+  calculatePriority(requestId) {
+    const hash = ethers4.keccak256(ethers4.concat([requestId, this.walletManager.getAddress()]));
+    return parseInt(hash.slice(2, 10), 16);
+  }
+  async stop() {
+    console.log("Stopping Noosphere Agent...");
+    await this.eventMonitor.stop();
+    this.scheduler.stop();
+    await this.containerManager.cleanup();
+    await this.containerManager.stopPersistentContainers();
+    this.isRunning = false;
+    console.log("\u2713 Agent stopped");
+  }
+  getStatus() {
+    return {
+      running: this.isRunning,
+      address: this.walletManager.getAddress(),
+      scheduler: this.scheduler.getStats(),
+      containers: {
+        runningCount: this.containerManager.getRunningContainerCount()
+      }
+    };
+  }
+  /**
+   * Get scheduler service (for advanced usage)
+   */
+  getScheduler() {
+    return this.scheduler;
+  }
+};
+
+// src/types/index.ts
+var FulfillResult = /* @__PURE__ */ ((FulfillResult2) => {
+  FulfillResult2[FulfillResult2["FULFILLED"] = 0] = "FULFILLED";
+  FulfillResult2[FulfillResult2["INVALID_REQUEST_ID"] = 1] = "INVALID_REQUEST_ID";
+  FulfillResult2[FulfillResult2["INVALID_COMMITMENT"] = 2] = "INVALID_COMMITMENT";
+  FulfillResult2[FulfillResult2["SUBSCRIPTION_BALANCE_INVARIANT_VIOLATION"] = 3] = "SUBSCRIPTION_BALANCE_INVARIANT_VIOLATION";
+  FulfillResult2[FulfillResult2["INSUFFICIENT_SUBSCRIPTION_BALANCE"] = 4] = "INSUFFICIENT_SUBSCRIPTION_BALANCE";
+  FulfillResult2[FulfillResult2["COST_EXCEEDS_COMMITMENT"] = 5] = "COST_EXCEEDS_COMMITMENT";
+  return FulfillResult2;
+})(FulfillResult || {});
+
+// src/utils/RequestIdUtils.ts
+import { ethers as ethers5 } from "ethers";
+var RequestIdUtils = class {
+  /**
+   * Pack subscriptionId and interval into requestId
+   * Matches Solidity: keccak256(abi.encodePacked(subscriptionId, interval))
+   */
+  static pack(subscriptionId, interval) {
+    const subscriptionIdBytes = ethers5.zeroPadValue(ethers5.toBeHex(subscriptionId), 8);
+    const intervalBytes = ethers5.zeroPadValue(ethers5.toBeHex(interval), 4);
+    const packed = ethers5.concat([subscriptionIdBytes, intervalBytes]);
+    return ethers5.keccak256(packed);
+  }
+  /**
+   * Unpack requestId into subscriptionId and interval (if stored separately)
+   * Note: This is not possible from the hash alone - only for informational purposes
+   * In practice, subscriptionId and interval are stored in events
+   */
+  static format(requestId, subscriptionId, interval) {
+    return `Request(id=${requestId.slice(0, 10)}..., sub=${subscriptionId}, interval=${interval})`;
+  }
+};
+
+// src/index.ts
+import { WalletManager as WalletManager2, KeystoreManager as KeystoreManager2 } from "@noosphere/crypto";
+import { RegistryManager as RegistryManager2 } from "@noosphere/registry";
+export {
+  CommitmentUtils,
+  ConfigLoader,
+  ContainerManager,
+  EventMonitor,
+  FulfillResult,
+  KeystoreManager2 as KeystoreManager,
+  NoosphereAgent,
+  RegistryManager2 as RegistryManager,
+  RequestIdUtils,
+  SchedulerService,
+  WalletManager2 as WalletManager
+};
+//# sourceMappingURL=index.js.map