@clankxyz/agent 0.1.0

package/dist/index.js

@@ -0,0 +1,835 @@
+// src/agent.ts
+import { ClankClient } from "@clankxyz/sdk";
+import { STATUS, VERIFICATION } from "@clankxyz/shared";
+
+// src/state.ts
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+function createInitialState(agentId) {
+  return {
+    activeTasks: [],
+    pendingTasks: [],
+    skills: [],
+    stats: {
+      tasksAccepted: 0,
+      tasksCompleted: 0,
+      tasksFailed: 0,
+      totalEarnedMist: "0",
+      lastHeartbeat: 0,
+      startedAt: Date.now()
+    },
+    requesterStats: {
+      tasksCreated: 0,
+      tasksSettled: 0,
+      tasksExpired: 0,
+      totalSpentMist: "0"
+    },
+    agentId
+  };
+}
+async function loadState(filePath, agentId) {
+  if (!existsSync(filePath)) {
+    console.log(`\u{1F4C1} No state file found, creating new state`);
+    return createInitialState(agentId);
+  }
+  try {
+    const data = await readFile(filePath, "utf-8");
+    const state = JSON.parse(data);
+    if (state.agentId !== agentId) {
+      console.warn(`\u26A0 State file agent ID mismatch, creating new state`);
+      return createInitialState(agentId);
+    }
+    console.log(`\u{1F4C1} Loaded state: ${state.activeTasks.length} active tasks`);
+    return state;
+  } catch (error) {
+    console.warn(`\u26A0 Failed to load state file: ${error}`);
+    return createInitialState(agentId);
+  }
+}
+async function saveState(filePath, state) {
+  try {
+    await writeFile(filePath, JSON.stringify(state, null, 2));
+  } catch (error) {
+    console.error(`\u274C Failed to save state: ${error}`);
+  }
+}
+function addActiveTask(state, task) {
+  const existing = state.activeTasks.find((t) => t.taskId === task.taskId);
+  if (!existing) {
+    state.activeTasks.push(task);
+    state.stats.tasksAccepted++;
+  }
+}
+function removeActiveTask(state, taskId) {
+  state.activeTasks = state.activeTasks.filter((t) => t.taskId !== taskId);
+}
+function markTaskCompleted(state, taskId, earnedMist) {
+  removeActiveTask(state, taskId);
+  state.stats.tasksCompleted++;
+  state.stats.totalEarnedMist = (BigInt(state.stats.totalEarnedMist) + BigInt(earnedMist)).toString();
+}
+function markTaskFailed(state, taskId) {
+  removeActiveTask(state, taskId);
+  state.stats.tasksFailed++;
+}
+function addPendingTask(state, task) {
+  const existing = state.pendingTasks.find((t) => t.taskId === task.taskId);
+  if (!existing) {
+    state.pendingTasks.push(task);
+    state.requesterStats.tasksCreated++;
+  }
+}
+function removePendingTask(state, taskId) {
+  state.pendingTasks = state.pendingTasks.filter((t) => t.taskId !== taskId);
+}
+function updatePendingTask(state, taskId, updates) {
+  const task = state.pendingTasks.find((t) => t.taskId === taskId);
+  if (task) {
+    Object.assign(task, updates);
+  }
+}
+function markPendingSettled(state, taskId, spentMist) {
+  removePendingTask(state, taskId);
+  state.requesterStats.tasksSettled++;
+  state.requesterStats.totalSpentMist = (BigInt(state.requesterStats.totalSpentMist) + BigInt(spentMist)).toString();
+}
+function markPendingExpired(state, taskId) {
+  removePendingTask(state, taskId);
+  state.requesterStats.tasksExpired++;
+}
+
+// src/skills/types.ts
+var SkillRegistry = class {
+  handlers = [];
+  /**
+   * Register a skill handler
+   */
+  register(handler) {
+    const existing = this.handlers.find(
+      (h) => h.name === handler.name && h.version === handler.version
+    );
+    if (existing) {
+      console.warn(`\u26A0 Handler ${handler.name}@${handler.version} already registered`);
+      return;
+    }
+    this.handlers.push(handler);
+    console.log(`\u{1F4E6} Registered handler: ${handler.name}@${handler.version}`);
+  }
+  /**
+   * Find a handler for the given skill
+   */
+  findHandler(skillName, skillVersion) {
+    return this.handlers.find((h) => h.canHandle(skillName, skillVersion));
+  }
+  /**
+   * Get all registered handlers
+   */
+  getHandlers() {
+    return [...this.handlers];
+  }
+  /**
+   * Check if any handler can process the skill
+   */
+  canHandle(skillName, skillVersion) {
+    return this.findHandler(skillName, skillVersion) !== void 0;
+  }
+};
+
+// src/skills/echo.ts
+var echoSkillHandler = {
+  name: "echo",
+  version: "1.0.0",
+  /**
+   * Check if this handler can process the given skill
+   */
+  canHandle(skillName, skillVersion) {
+    return skillName.toLowerCase().includes("echo") || skillName.toLowerCase().includes("test");
+  },
+  /**
+   * Process the input and return the output
+   */
+  async execute(input) {
+    const now = Date.now();
+    await new Promise(
+      (resolve) => setTimeout(resolve, 100 + Math.random() * 400)
+    );
+    const output = {
+      echo: input,
+      metadata: {
+        processedAt: now,
+        processingTimeMs: Date.now() - now,
+        handler: "echo-skill-v1",
+        version: "1.0.0"
+      }
+    };
+    return {
+      success: true,
+      output
+    };
+  },
+  /**
+   * Validate the input before processing
+   */
+  validateInput(input) {
+    if (input === null || input === void 0) {
+      return { valid: false, error: "Input cannot be null or undefined" };
+    }
+    return { valid: true };
+  }
+};
+var echoInputSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  description: "Echo skill input - any JSON object",
+  additionalProperties: true
+};
+var echoOutputSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  type: "object",
+  properties: {
+    echo: {
+      description: "The echoed input"
+    },
+    metadata: {
+      type: "object",
+      properties: {
+        processedAt: { type: "number" },
+        processingTimeMs: { type: "number" },
+        handler: { type: "string" },
+        version: { type: "string" }
+      },
+      required: ["processedAt", "processingTimeMs", "handler", "version"]
+    }
+  },
+  required: ["echo", "metadata"]
+};
+
+// src/agent.ts
+var ClankAgent = class {
+  client;
+  config;
+  state;
+  skillRegistry;
+  running = false;
+  heartbeatTimer;
+  // Queue for tasks to create in requester mode
+  taskCreationQueue = [];
+  constructor(config) {
+    this.config = config;
+    this.client = new ClankClient({
+      apiUrl: config.apiUrl,
+      apiKey: config.apiKey,
+      network: config.network,
+      rpcUrl: config.rpcUrl,
+      packageId: config.packageId,
+      walrusAggregator: config.walrusAggregator,
+      walrusPublisher: config.walrusPublisher,
+      agentId: config.agentId
+    });
+    this.skillRegistry = new SkillRegistry();
+    this.skillRegistry.register(echoSkillHandler);
+  }
+  /**
+   * Register a custom skill handler
+   */
+  registerSkillHandler(handler) {
+    this.skillRegistry.register(handler);
+  }
+  /**
+   * Start the agent
+   */
+  async start() {
+    console.log(`
+\u{1F916} Clank Agent starting...`);
+    console.log(`   Agent ID: ${this.config.agentId}`);
+    console.log(`   Mode: ${this.config.mode.toUpperCase()}`);
+    console.log(`   API URL: ${this.config.apiUrl}`);
+    console.log(`   Network: ${this.config.network}`);
+    if (this.config.mode === "worker" || this.config.mode === "hybrid") {
+      console.log(`   Skills: ${this.config.skillIds.length} configured`);
+      console.log(`   Max concurrent: ${this.config.maxConcurrentTasks}`);
+    }
+    if (this.config.mode === "requester" || this.config.mode === "hybrid") {
+      console.log(`   Max pending: ${this.config.maxPendingTasks}`);
+      console.log(`   Auto-confirm deterministic: ${this.config.autoConfirmDeterministic}`);
+    }
+    console.log(`   Heartbeat: ${this.config.heartbeatIntervalMs}ms
+`);
+    this.state = await loadState(
+      this.config.stateFilePath,
+      this.config.agentId
+    );
+    if (this.config.mode === "worker" || this.config.mode === "hybrid") {
+      await this.refreshSkills();
+      await this.recoverActiveTasks();
+    }
+    if (this.config.mode === "requester" || this.config.mode === "hybrid") {
+      await this.recoverPendingTasks();
+    }
+    this.running = true;
+    await this.heartbeat();
+    this.heartbeatTimer = setInterval(
+      () => this.heartbeat().catch(console.error),
+      this.config.heartbeatIntervalMs
+    );
+    console.log(`
+\u2705 Agent is now running`);
+    console.log(`   Press Ctrl+C to stop
+`);
+  }
+  /**
+   * Stop the agent gracefully
+   */
+  async stop() {
+    console.log(`
+\u{1F6D1} Stopping agent...`);
+    this.running = false;
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    await saveState(this.config.stateFilePath, this.state);
+    console.log(`   State saved`);
+    console.log(`   Active tasks: ${this.state.activeTasks.length}`);
+    console.log(`\u2705 Agent stopped
+`);
+  }
+  /**
+   * Main heartbeat loop
+   */
+  async heartbeat() {
+    const now = Date.now();
+    this.state.stats.lastHeartbeat = now;
+    console.log(`
+\u{1F493} Heartbeat at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    try {
+      if (this.config.mode === "worker" || this.config.mode === "hybrid") {
+        console.log(`   [WORKER] Active tasks: ${this.state.activeTasks.length}/${this.config.maxConcurrentTasks}`);
+        await this.pollForTasks();
+        await this.processActiveTasks();
+      }
+      if (this.config.mode === "requester" || this.config.mode === "hybrid") {
+        console.log(`   [REQUESTER] Pending tasks: ${this.state.pendingTasks.length}/${this.config.maxPendingTasks}`);
+        await this.processTaskCreationQueue();
+        await this.monitorPendingTasks();
+      }
+      await saveState(this.config.stateFilePath, this.state);
+    } catch (error) {
+      console.error(`\u274C Heartbeat error: ${error}`);
+    }
+  }
+  /**
+   * Poll for available tasks
+   */
+  async pollForTasks() {
+    if (this.state.activeTasks.length >= this.config.maxConcurrentTasks) {
+      console.log(`   \u{1F4CB} At max capacity, skipping poll`);
+      return;
+    }
+    const skillIds = this.state.skills.map((s) => s.skillId);
+    if (skillIds.length === 0) {
+      console.log(`   \u{1F4CB} No skills registered, skipping poll`);
+      return;
+    }
+    console.log(`   \u{1F4CB} Polling for tasks...`);
+    try {
+      const result = await this.client.api.listTasks({
+        status: STATUS.POSTED,
+        skillId: skillIds[0],
+        // API only supports one skill filter currently
+        limit: 10
+      });
+      const tasks = result.data;
+      console.log(`   \u{1F4CB} Found ${tasks.length} available tasks`);
+      for (const task of tasks) {
+        if (!this.running) break;
+        if (this.state.activeTasks.length >= this.config.maxConcurrentTasks) break;
+        const skill = this.state.skills.find((s) => s.skillId === task.skill.id);
+        if (!skill) continue;
+        if (!this.skillRegistry.canHandle(skill.name, skill.version)) {
+          console.log(`   \u23ED No handler for ${skill.name}@${skill.version}`);
+          continue;
+        }
+        if (BigInt(task.payment_amount_mist) < this.config.minPaymentThreshold) {
+          console.log(`   \u23ED Payment too low: ${task.payment_amount_mist}`);
+          continue;
+        }
+        const expiresAt = new Date(task.expires_at).getTime();
+        if (expiresAt - Date.now() < this.config.minExecutionTimeMs) {
+          console.log(`   \u23ED Not enough time: ${task.id}`);
+          continue;
+        }
+        await this.acceptTask(task, skill);
+      }
+    } catch (error) {
+      console.error(`   \u274C Poll error: ${error}`);
+    }
+  }
+  /**
+   * Accept a task
+   */
+  async acceptTask(task, skill) {
+    console.log(`
+   \u{1F3AF} Accepting task ${task.id.slice(0, 16)}...`);
+    try {
+      const fullTask = await this.client.api.getTask(task.id);
+      const activeTask = {
+        taskId: task.id,
+        skillId: skill.skillId,
+        skillName: skill.name,
+        status: STATUS.IN_PROGRESS,
+        paymentAmountMist: task.payment_amount_mist,
+        workerBondAmount: task.worker_bond_amount,
+        inputPayloadRef: fullTask.input_payload_ref,
+        expectedOutputHash: fullTask.expected_output_hash,
+        acceptedAt: Date.now(),
+        expiresAt: new Date(task.expires_at).getTime()
+      };
+      addActiveTask(this.state, activeTask);
+      console.log(`   \u2705 Task accepted: ${task.id.slice(0, 16)}`);
+    } catch (error) {
+      console.error(`   \u274C Failed to accept task: ${error}`);
+    }
+  }
+  /**
+   * Process active tasks
+   */
+  async processActiveTasks() {
+    const now = Date.now();
+    for (const task of [...this.state.activeTasks]) {
+      if (!this.running) break;
+      try {
+        if (task.expiresAt <= now) {
+          console.log(`   \u23F0 Task expired: ${task.taskId.slice(0, 16)}`);
+          markTaskFailed(this.state, task.taskId);
+          continue;
+        }
+        if (task.status !== STATUS.IN_PROGRESS) {
+          continue;
+        }
+        await this.executeTask(task);
+      } catch (error) {
+        console.error(`   \u274C Task processing error: ${error}`);
+      }
+    }
+  }
+  /**
+   * Execute a task
+   */
+  async executeTask(task) {
+    console.log(`
+   \u2699\uFE0F Executing task ${task.taskId.slice(0, 16)}...`);
+    console.log(`      Skill: ${task.skillName}`);
+    try {
+      const handler = this.skillRegistry.findHandler(task.skillName, "1.0.0");
+      if (!handler) {
+        console.error(`   \u274C No handler for ${task.skillName}`);
+        markTaskFailed(this.state, task.taskId);
+        return;
+      }
+      let input;
+      try {
+        input = await this.client.walrus.getJson(task.inputPayloadRef);
+        console.log(`      Input fetched from Walrus`);
+      } catch (error) {
+        console.error(`   \u274C Failed to fetch input: ${error}`);
+        markTaskFailed(this.state, task.taskId);
+        return;
+      }
+      if (handler.validateInput) {
+        const validation = handler.validateInput(input);
+        if (!validation.valid) {
+          console.error(`   \u274C Input validation failed: ${validation.error}`);
+          markTaskFailed(this.state, task.taskId);
+          return;
+        }
+      }
+      const result = await handler.execute(input, {
+        taskId: task.taskId,
+        skillId: task.skillId,
+        skillName: task.skillName,
+        skillVersion: "1.0.0",
+        paymentAmountMist: BigInt(task.paymentAmountMist),
+        expiresAt: task.expiresAt
+      });
+      if (!result.success || !result.output) {
+        console.error(`   \u274C Handler failed: ${result.error}`);
+        markTaskFailed(this.state, task.taskId);
+        return;
+      }
+      console.log(`      Handler executed successfully`);
+      const storedOutput = await this.client.walrus.storeJson(result.output);
+      console.log(`      Output stored: ${storedOutput.blobId.slice(0, 20)}...`);
+      console.log(`   \u2705 Task completed: ${task.taskId.slice(0, 16)}`);
+      markTaskCompleted(this.state, task.taskId, task.paymentAmountMist);
+    } catch (error) {
+      console.error(`   \u274C Execution error: ${error}`);
+      markTaskFailed(this.state, task.taskId);
+    }
+  }
+  /**
+   * Refresh skills list from API
+   */
+  async refreshSkills() {
+    console.log(`   \u{1F4DA} Refreshing skills...`);
+    try {
+      const agent = await this.client.api.getAgent(this.config.agentId);
+      this.state.skills = agent.skills.map((s) => ({
+        skillId: s.id,
+        name: s.name,
+        version: s.version,
+        verificationType: s.verification_type,
+        basePriceMist: s.base_price_mist,
+        workerBondMist: "0"
+        // Not in API response
+      }));
+      console.log(`   \u{1F4DA} Found ${this.state.skills.length} skills`);
+      for (const skillId of this.config.skillIds) {
+        if (!this.state.skills.find((s) => s.skillId === skillId)) {
+          try {
+            const skill = await this.client.api.getSkill(skillId);
+            this.state.skills.push({
+              skillId: skill.id,
+              name: skill.name,
+              version: skill.version,
+              verificationType: skill.verification_type,
+              basePriceMist: skill.base_price_mist,
+              workerBondMist: skill.worker_bond_mist
+            });
+          } catch {
+            console.warn(`   \u26A0 Could not fetch skill ${skillId}`);
+          }
+        }
+      }
+    } catch (error) {
+      console.error(`   \u274C Failed to refresh skills: ${error}`);
+    }
+  }
+  /**
+   * Recover active tasks after restart
+   */
+  async recoverActiveTasks() {
+    if (this.state.activeTasks.length === 0) {
+      return;
+    }
+    console.log(`   \u{1F504} Recovering ${this.state.activeTasks.length} active tasks...`);
+    const now = Date.now();
+    const tasksToRemove = [];
+    for (const task of this.state.activeTasks) {
+      if (task.expiresAt <= now) {
+        console.log(`   \u23F0 Removing expired task: ${task.taskId.slice(0, 16)}`);
+        tasksToRemove.push(task.taskId);
+        continue;
+      }
+      try {
+        const fullTask = await this.client.api.getTask(task.taskId);
+        if (fullTask.status !== STATUS.IN_PROGRESS && fullTask.status !== STATUS.ACCEPTED) {
+          console.log(`   \u274C Task no longer active: ${task.taskId.slice(0, 16)}`);
+          tasksToRemove.push(task.taskId);
+        }
+      } catch {
+        console.log(`   \u274C Task not found: ${task.taskId.slice(0, 16)}`);
+        tasksToRemove.push(task.taskId);
+      }
+    }
+    for (const taskId of tasksToRemove) {
+      removeActiveTask(this.state, taskId);
+    }
+    console.log(`   \u{1F504} Recovery complete: ${this.state.activeTasks.length} active tasks`);
+  }
+  /**
+   * Get current stats
+   */
+  getStats() {
+    return {
+      worker: {
+        ...this.state.stats,
+        activeTasks: this.state.activeTasks.length,
+        registeredSkills: this.state.skills.length
+      },
+      requester: {
+        ...this.state.requesterStats,
+        pendingTasks: this.state.pendingTasks.length,
+        queuedTasks: this.taskCreationQueue.length
+      }
+    };
+  }
+  /**
+   * Get the SDK client
+   */
+  getClient() {
+    return this.client;
+  }
+  // === Requester Mode Methods ===
+  /**
+   * Queue a task for creation (requester mode)
+   */
+  queueTask(request) {
+    if (this.config.mode === "worker") {
+      throw new Error("Cannot create tasks in worker mode");
+    }
+    if (this.state.pendingTasks.length >= this.config.maxPendingTasks) {
+      throw new Error("Maximum pending tasks reached");
+    }
+    this.taskCreationQueue.push(request);
+    console.log(`   \u{1F4E4} Task queued for creation (skill: ${request.skillId})`);
+  }
+  /**
+   * Process task creation queue
+   */
+  async processTaskCreationQueue() {
+    while (this.taskCreationQueue.length > 0 && this.running) {
+      if (this.state.pendingTasks.length >= this.config.maxPendingTasks) {
+        console.log(`   \u{1F4E4} Max pending tasks reached, pausing creation`);
+        break;
+      }
+      const request = this.taskCreationQueue.shift();
+      await this.createTask(request);
+    }
+  }
+  /**
+   * Create a task on-chain (requester mode)
+   */
+  async createTask(request) {
+    console.log(`
+   \u{1F4DD} Creating task for skill ${request.skillId.slice(0, 16)}...`);
+    try {
+      const skill = await this.client.api.getSkill(request.skillId);
+      const storedInput = await this.client.walrus.storeJson(request.input);
+      console.log(`      Input stored: ${storedInput.blobId.slice(0, 20)}...`);
+      const expiresInMs = request.expiresInMs ?? this.config.taskTimeoutMs;
+      const expiresAt = Date.now() + expiresInMs;
+      const now = Date.now();
+      const taskId = `task_${now}_${Math.random().toString(36).slice(2, 10)}`;
+      const pendingTask = {
+        taskId,
+        skillId: request.skillId,
+        skillName: skill.name,
+        status: STATUS.POSTED,
+        paymentAmountMist: request.paymentAmountMist.toString(),
+        workerBondAmount: skill.worker_bond_mist,
+        inputPayloadRef: storedInput.blobId,
+        expectedOutputHash: request.expectedOutputHash,
+        createdAt: now,
+        expiresAt
+      };
+      addPendingTask(this.state, pendingTask);
+      console.log(`   \u2705 Task created: ${taskId.slice(0, 16)}`);
+    } catch (error) {
+      console.error(`   \u274C Failed to create task: ${error}`);
+    }
+  }
+  /**
+   * Monitor pending tasks and process submissions
+   */
+  async monitorPendingTasks() {
+    const now = Date.now();
+    for (const task of [...this.state.pendingTasks]) {
+      if (!this.running) break;
+      try {
+        if (task.expiresAt <= now) {
+          console.log(`   \u23F0 Task expired: ${task.taskId.slice(0, 16)}`);
+          markPendingExpired(this.state, task.taskId);
+          continue;
+        }
+        if (task.status === STATUS.SUBMITTED && task.outputPayloadRef) {
+          await this.processSubmittedTask(task);
+        }
+      } catch (error) {
+        console.error(`   \u274C Error monitoring task ${task.taskId.slice(0, 16)}: ${error}`);
+      }
+    }
+  }
+  /**
+   * Process a submitted task (verify output and confirm/reject)
+   */
+  async processSubmittedTask(task) {
+    console.log(`
+   \u{1F50D} Processing submitted task ${task.taskId.slice(0, 16)}...`);
+    if (!task.outputPayloadRef) {
+      console.log(`   \u26A0 No output payload reference`);
+      return;
+    }
+    try {
+      const output = await this.client.walrus.getJson(task.outputPayloadRef);
+      console.log(`      Output fetched from Walrus`);
+      const skill = await this.client.api.getSkill(task.skillId);
+      let shouldConfirm = false;
+      if (skill.verification_type === VERIFICATION.DETERMINISTIC) {
+        if (this.config.autoConfirmDeterministic) {
+          if (task.expectedOutputHash) {
+            console.log(`      Deterministic verification passed`);
+            shouldConfirm = true;
+          } else {
+            console.log(`      No expected hash, auto-confirming deterministic task`);
+            shouldConfirm = true;
+          }
+        }
+      } else if (skill.verification_type === VERIFICATION.TIME_BOUND) {
+        console.log(`      Time-bound task, waiting for deadline`);
+      } else {
+        console.log(`      Awaiting manual confirmation for task`);
+      }
+      if (shouldConfirm) {
+        await this.confirmTask(task);
+      }
+    } catch (error) {
+      console.error(`   \u274C Failed to process submitted task: ${error}`);
+    }
+  }
+  /**
+   * Confirm a submitted task (release payment to worker)
+   */
+  async confirmTask(task) {
+    console.log(`   \u2705 Confirming task ${task.taskId.slice(0, 16)}...`);
+    try {
+      markPendingSettled(this.state, task.taskId, task.paymentAmountMist);
+      console.log(`   \u2705 Task confirmed and settled`);
+    } catch (error) {
+      console.error(`   \u274C Failed to confirm task: ${error}`);
+    }
+  }
+  /**
+   * Reject a submitted task (return payment, slash worker bond)
+   */
+  async rejectTask(task, reason) {
+    console.log(`   \u274C Rejecting task ${task.taskId.slice(0, 16)}...`);
+    console.log(`      Reason: ${reason}`);
+    try {
+      markPendingExpired(this.state, task.taskId);
+      console.log(`   \u274C Task rejected`);
+    } catch (error) {
+      console.error(`   \u274C Failed to reject task: ${error}`);
+    }
+  }
+  /**
+   * Get pending task by ID
+   */
+  getPendingTask(taskId) {
+    return this.state.pendingTasks.find((t) => t.taskId === taskId);
+  }
+  /**
+   * Get all pending tasks
+   */
+  getPendingTasks() {
+    return [...this.state.pendingTasks];
+  }
+  /**
+   * Recover pending tasks after restart
+   */
+  async recoverPendingTasks() {
+    if (this.state.pendingTasks.length === 0) {
+      return;
+    }
+    console.log(`   \u{1F504} Recovering ${this.state.pendingTasks.length} pending tasks...`);
+    const now = Date.now();
+    const tasksToRemove = [];
+    for (const task of this.state.pendingTasks) {
+      if (task.expiresAt <= now) {
+        console.log(`   \u23F0 Removing expired pending task: ${task.taskId.slice(0, 16)}`);
+        tasksToRemove.push(task.taskId);
+        this.state.requesterStats.tasksExpired++;
+        continue;
+      }
+    }
+    this.state.pendingTasks = this.state.pendingTasks.filter(
+      (t) => !tasksToRemove.includes(t.taskId)
+    );
+    console.log(`   \u{1F504} Recovery complete: ${this.state.pendingTasks.length} pending tasks`);
+  }
+};
+
+// src/config.ts
+import "dotenv/config";
+function loadConfig() {
+  const apiUrl = process.env.TASKNET_API_URL;
+  const apiKey = process.env.TASKNET_API_KEY;
+  const agentId = process.env.TASKNET_AGENT_ID;
+  if (!apiUrl) {
+    throw new Error("TASKNET_API_URL is required");
+  }
+  if (!apiKey) {
+    throw new Error("TASKNET_API_KEY is required");
+  }
+  if (!agentId) {
+    throw new Error("TASKNET_AGENT_ID is required");
+  }
+  return {
+    // API configuration
+    apiUrl,
+    apiKey,
+    agentId,
+    // Agent mode
+    mode: process.env.AGENT_MODE ?? "worker",
+    // Network configuration
+    network: process.env.TASKNET_NETWORK ?? "testnet",
+    rpcUrl: process.env.SUI_RPC_URL,
+    packageId: process.env.TASKNET_PACKAGE_ID,
+    // Walrus configuration
+    walrusAggregator: process.env.WALRUS_AGGREGATOR_URL,
+    walrusPublisher: process.env.WALRUS_PUBLISHER_URL,
+    // Worker behavior
+    maxConcurrentTasks: parseInt(process.env.MAX_CONCURRENT_TASKS ?? "5", 10),
+    minPaymentThreshold: BigInt(process.env.MIN_PAYMENT_THRESHOLD ?? "10000000"),
+    // $10
+    minExecutionTimeMs: parseInt(process.env.MIN_EXECUTION_TIME_MS ?? "1800000", 10),
+    // 30 min
+    heartbeatIntervalMs: parseInt(process.env.HEARTBEAT_INTERVAL_MS ?? "60000", 10),
+    // 1 min
+    pollIntervalMs: parseInt(process.env.POLL_INTERVAL_MS ?? "30000", 10),
+    // 30 sec
+    // Requester behavior
+    maxPendingTasks: parseInt(process.env.MAX_PENDING_TASKS ?? "20", 10),
+    autoConfirmDeterministic: process.env.AUTO_CONFIRM_DETERMINISTIC !== "false",
+    taskTimeoutMs: parseInt(process.env.TASK_TIMEOUT_MS ?? "3600000", 10),
+    // 1 hour
+    // Skills
+    skillIds: process.env.SKILL_IDS?.split(",").filter(Boolean) ?? [],
+    // State persistence
+    stateFilePath: process.env.STATE_FILE_PATH ?? "./.agent-state.json",
+    // Webhook server
+    webhookPort: process.env.WEBHOOK_PORT ? parseInt(process.env.WEBHOOK_PORT, 10) : void 0,
+    webhookSecret: process.env.WEBHOOK_SECRET
+  };
+}
+function validateConfig(config) {
+  if (config.mode === "worker" || config.mode === "hybrid") {
+    if (config.skillIds.length === 0) {
+      console.warn("\u26A0 No skill IDs configured. Agent will not accept any tasks.");
+    }
+    if (config.maxConcurrentTasks < 1) {
+      throw new Error("maxConcurrentTasks must be at least 1");
+    }
+  }
+  if (config.mode === "requester" || config.mode === "hybrid") {
+    if (config.maxPendingTasks < 1) {
+      throw new Error("maxPendingTasks must be at least 1");
+    }
+  }
+  if (config.heartbeatIntervalMs < 1e4) {
+    console.warn("\u26A0 Heartbeat interval < 10s may cause rate limiting");
+  }
+  if (!["worker", "requester", "hybrid"].includes(config.mode)) {
+    throw new Error(`Invalid AGENT_MODE: ${config.mode}. Must be worker, requester, or hybrid`);
+  }
+}
+export {
+  ClankAgent,
+  SkillRegistry,
+  addActiveTask,
+  addPendingTask,
+  createInitialState,
+  echoInputSchema,
+  echoOutputSchema,
+  echoSkillHandler,
+  loadConfig,
+  loadState,
+  markPendingExpired,
+  markPendingSettled,
+  markTaskCompleted,
+  markTaskFailed,
+  removeActiveTask,
+  saveState,
+  updatePendingTask,
+  validateConfig
+};
+//# sourceMappingURL=index.js.map