@elisym/cli 0.17.1 → 0.18.0

package/dist/index.js

@@ -27,6 +27,14 @@ var __export = (target, all) => {
 };
 
 // src/llm/providers/http.ts
+function resolveLlmTimeoutMs() {
+  const raw = process.env.ELISYM_LLM_TIMEOUT_MS;
+  if (raw === void 0) {
+    return DEFAULT_LLM_TIMEOUT_MS;
+  }
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_LLM_TIMEOUT_MS;
+}
 function createAbortError() {
   const err = new Error("The operation was aborted");
   err.name = "AbortError";
@@ -92,10 +100,11 @@ async function fetchWithRetry(url, init, signal) {
     await sleepWithSignal(delay, signal);
   }
 }
-var LLM_TIMEOUT_MS, MAX_RETRIES, RETRYABLE_STATUSES;
+var DEFAULT_LLM_TIMEOUT_MS, LLM_TIMEOUT_MS, MAX_RETRIES, RETRYABLE_STATUSES;
 var init_http = __esm({
   "src/llm/providers/http.ts"() {
-    LLM_TIMEOUT_MS = 12e4;
+    DEFAULT_LLM_TIMEOUT_MS = 6e5;
+    LLM_TIMEOUT_MS = resolveLlmTimeoutMs();
     MAX_RETRIES = 2;
     RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
   }
@@ -1977,7 +1986,6 @@ function createLogger(options = {}) {
 var payment = new SolanaPaymentStrategy();
 var LEDGER_GC_INTERVAL_MS = 60 * 60 * 1e3;
 var LEDGER_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
-var TOTAL_JOB_TIMEOUT_MS = 5 * 60 * 1e3;
 var MAX_PAID_AGE_MS = 24 * 60 * 60 * 1e3;
 var SIG_PATH_TIMEOUT_MS = 60 * 1e3;
 function resolveJobPrice(tags, skills) {
@@ -2012,6 +2020,12 @@ var AgentUnavailableError = class extends Error {
     this.name = "AgentUnavailableError";
   }
 };
+var ExecutionBudgetExceededError = class extends Error {
+  constructor(budgetMs) {
+    super(`Execution exceeded budget (${Math.round(budgetMs / 1e3)}s)`);
+    this.name = "ExecutionBudgetExceededError";
+  }
+};
 function bodyLooksLikeBilling3(body) {
   const lower = body.toLowerCase();
   return BILLING_BODY_MARKERS3.some((marker) => lower.includes(marker));
@@ -2035,8 +2049,10 @@ function resolveHealthPair(skill) {
   return null;
 }
 var RATE_LIMIT_WINDOW_MS = 10 * 60 * 1e3;
-var MAX_JOBS_PER_CUSTOMER = 20;
-var GLOBAL_MAX_JOBS_PER_WINDOW = 200;
+var FREE_MAX_JOBS_PER_CUSTOMER = 20;
+var FREE_GLOBAL_MAX_JOBS_PER_WINDOW = 200;
+var PAID_MAX_JOBS_PER_CUSTOMER = 200;
+var PAID_GLOBAL_MAX_JOBS_PER_WINDOW = 2e3;
 var MAX_TRACKED_CUSTOMERS = 1e3;
 var GLOBAL_LIMITER_KEY = "__global__";
 var AgentRuntime = class {
@@ -2060,16 +2076,32 @@ var AgentRuntime = class {
   recoveryInterval = null;
   gcInterval = null;
   stopped = false;
-  /** Per-customer sliding-window rate limiter (keyed on customer pubkey). */
-  customerLimiter = createSlidingWindowLimiter({
+  /** Per-customer sliding-window rate limiter for free skills. */
+  freeCustomerLimiter = createSlidingWindowLimiter({
     windowMs: RATE_LIMIT_WINDOW_MS,
-    maxPerWindow: MAX_JOBS_PER_CUSTOMER,
+    maxPerWindow: FREE_MAX_JOBS_PER_CUSTOMER,
     maxKeys: MAX_TRACKED_CUSTOMERS
   });
-  /** Global sliding-window rate limiter (Sybil protection). */
-  globalLimiter = createSlidingWindowLimiter({
+  /** Global sliding-window rate limiter for free skills (Sybil protection). */
+  freeGlobalLimiter = createSlidingWindowLimiter({
     windowMs: RATE_LIMIT_WINDOW_MS,
-    maxPerWindow: GLOBAL_MAX_JOBS_PER_WINDOW,
+    maxPerWindow: FREE_GLOBAL_MAX_JOBS_PER_WINDOW,
+    maxKeys: 1
+  });
+  /**
+   * Per-customer sliding-window limiter for paid skills (10x looser than free).
+   * Payment is the primary economic deterrent; this cap exists to bound the
+   * "claim paid skill but never pay" queue-spam vector.
+   */
+  paidCustomerLimiter = createSlidingWindowLimiter({
+    windowMs: RATE_LIMIT_WINDOW_MS,
+    maxPerWindow: PAID_MAX_JOBS_PER_CUSTOMER,
+    maxKeys: MAX_TRACKED_CUSTOMERS
+  });
+  /** Global sliding-window limiter for paid skills (Sybil protection, 10x free). */
+  paidGlobalLimiter = createSlidingWindowLimiter({
+    windowMs: RATE_LIMIT_WINDOW_MS,
+    maxPerWindow: PAID_GLOBAL_MAX_JOBS_PER_WINDOW,
     maxKeys: 1
   });
   /**
@@ -2247,17 +2279,20 @@ var AgentRuntime = class {
         });
         return;
       }
-      if (!this.customerLimiter.peek(job.customerId).allowed) {
+      const matched = this.skills.route(job.tags);
+      const isPaid = matched ? matched.priceSubunits > 0 : false;
+      const customerLimiter = isPaid ? this.paidCustomerLimiter : this.freeCustomerLimiter;
+      const globalLimiter = isPaid ? this.paidGlobalLimiter : this.freeGlobalLimiter;
+      if (!customerLimiter.peek(job.customerId).allowed) {
         this.transport.sendFeedback(job, { type: "error", message: "Rate limited, try again later" }).catch(() => {
         });
         return;
       }
-      if (!this.globalLimiter.peek(GLOBAL_LIMITER_KEY).allowed) {
+      if (!globalLimiter.peek(GLOBAL_LIMITER_KEY).allowed) {
         this.transport.sendFeedback(job, { type: "error", message: "Server busy, try again later" }).catch(() => {
         });
         return;
       }
-      const matched = this.skills.route(job.tags);
       const isFreeLlm = matched?.mode === "llm" && matched.priceSubunits === 0;
       let perCustomerLimiter;
       let perSkillKey;
@@ -2278,8 +2313,8 @@ var AgentRuntime = class {
           return;
         }
       }
-      this.customerLimiter.check(job.customerId);
-      this.globalLimiter.check(GLOBAL_LIMITER_KEY);
+      customerLimiter.check(job.customerId);
+      globalLimiter.check(GLOBAL_LIMITER_KEY);
       if (isFreeLlm && perCustomerLimiter && perSkillKey) {
         this.freeLlmLimiters.globalLimiter.check(FREE_LLM_GLOBAL_KEY);
         perCustomerLimiter.check(perSkillKey);
@@ -2313,8 +2348,10 @@ var AgentRuntime = class {
   }
   /** Drop expired hits from every sliding-window limiter. */
   cleanupRateLimits() {
-    this.customerLimiter.prune();
-    this.globalLimiter.prune();
+    this.freeCustomerLimiter.prune();
+    this.freeGlobalLimiter.prune();
+    this.paidCustomerLimiter.prune();
+    this.paidGlobalLimiter.prune();
     this.freeLlmLimiters.globalLimiter.prune();
     this.freeLlmLimiters.prunePerCustomer();
   }
@@ -2343,21 +2380,26 @@ var AgentRuntime = class {
     }
     this.transport.stop();
   }
-  /** Wrapper with total job timeout and error handling. */
+  /**
+   * Resolve a job's execution budget in milliseconds. Per-skill
+   * `executionTimeoutSecs` wins over the agent-level `config.executionTimeoutSecs`;
+   * `0` (explicit unlimited) and `undefined` both collapse to `0` => no timer.
+   */
+  resolveExecutionBudgetMs(skill) {
+    const secs = skill.executionTimeoutSecs ?? this.config.executionTimeoutSecs ?? 0;
+    return secs > 0 ? secs * 1e3 : 0;
+  }
+  /**
+   * Wrapper with error handling. The execution budget (if any) is enforced
+   * around `skill.execute` inside `executeJob`, not here - payment collection
+   * and result delivery run on their own bounds. `jobAbort` is retained so
+   * `stop()` can still abort an in-flight job.
+   */
   async processJob(job) {
-    let timeoutId;
     const jobAbort = new AbortController();
     this.jobAbortControllers.add(jobAbort);
     try {
-      await Promise.race([
-        this.executeJob(job, jobAbort.signal),
-        new Promise((_, reject) => {
-          timeoutId = setTimeout(() => {
-            jobAbort.abort();
-            reject(new Error("Job processing timeout"));
-          }, TOTAL_JOB_TIMEOUT_MS);
-        })
-      ]);
+      await this.executeJob(job, jobAbort.signal);
     } catch (e) {
       const log = this.callbacks.onLog ?? console.log;
       log(`[${job.jobId.slice(0, 8)}] Error: ${e.message}`);
@@ -2383,7 +2425,6 @@ var AgentRuntime = class {
       await this.transport.sendFeedback(job, { type: "error", message: safeMessage }).catch(() => {
       });
     } finally {
-      clearTimeout(timeoutId);
       this.jobAbortControllers.delete(jobAbort);
     }
   }
@@ -2445,6 +2486,21 @@ var AgentRuntime = class {
     }
     log(`[${job.jobId.slice(0, 8)}] Executing skill: ${skill.name}`);
     let output;
+    const budgetMs = this.resolveExecutionBudgetMs(skill);
+    let budgetExceeded = false;
+    const execAbort = new AbortController();
+    const onOuterAbort = () => execAbort.abort();
+    if (signal) {
+      if (signal.aborted) {
+        execAbort.abort();
+      } else {
+        signal.addEventListener("abort", onOuterAbort);
+      }
+    }
+    const budgetTimer = budgetMs > 0 ? setTimeout(() => {
+      budgetExceeded = true;
+      execAbort.abort();
+    }, budgetMs) : void 0;
     try {
       output = await skill.execute(
         {
@@ -2453,14 +2509,25 @@ var AgentRuntime = class {
           tags: job.tags,
           jobId: job.jobId
         },
-        { ...this.skillCtx, signal }
+        { ...this.skillCtx, signal: execAbort.signal }
       );
     } catch (err) {
+      if (budgetExceeded) {
+        log(`[${job.jobId.slice(0, 8)}] Execution exceeded budget (${budgetMs / 1e3}s)`);
+        throw new ExecutionBudgetExceededError(budgetMs);
+      }
       const flippedToUnhealthy = this.markHealthFromExecuteError(skill, err, log, job.jobId);
       if (flippedToUnhealthy) {
         throw new AgentUnavailableError();
       }
       throw err;
+    } finally {
+      if (budgetTimer) {
+        clearTimeout(budgetTimer);
+      }
+      if (signal) {
+        signal.removeEventListener("abort", onOuterAbort);
+      }
     }
     this.ledger.markExecuted(job.jobId, output.data);
     log(`[${job.jobId.slice(0, 8)}] Skill completed, delivering result`);
@@ -2708,7 +2775,6 @@ var AgentRuntime = class {
   async recoverSingleJob(entry, log) {
     const recoveryAbort = new AbortController();
     this.jobAbortControllers.add(recoveryAbort);
-    const timeout = setTimeout(() => recoveryAbort.abort(), TOTAL_JOB_TIMEOUT_MS);
     try {
       const rawEvent = JSON.parse(entry.raw_event_json);
       const fakeJob = {
@@ -2765,22 +2831,30 @@ var AgentRuntime = class {
             return;
           }
         }
-        const output = await skill.execute(
-          {
-            data: entry.input,
-            inputType: entry.input_type,
-            tags: entry.tags,
-            jobId: entry.job_id
-          },
-          { ...this.skillCtx, signal: recoveryAbort.signal }
-        );
+        const recoveryBudgetMs = this.resolveExecutionBudgetMs(skill);
+        const budgetTimer = recoveryBudgetMs > 0 ? setTimeout(() => recoveryAbort.abort(), recoveryBudgetMs) : void 0;
+        let output;
+        try {
+          output = await skill.execute(
+            {
+              data: entry.input,
+              inputType: entry.input_type,
+              tags: entry.tags,
+              jobId: entry.job_id
+            },
+            { ...this.skillCtx, signal: recoveryAbort.signal }
+          );
+        } finally {
+          if (budgetTimer) {
+            clearTimeout(budgetTimer);
+          }
+        }
         this.ledger.markExecuted(entry.job_id, output.data);
         await this.transport.deliverResult(fakeJob, output.data, entry.net_amount);
         this.ledger.markDelivered(entry.job_id);
         log(`[${entry.job_id.slice(0, 8)}] Recovery: re-executed and delivered`);
       }
     } finally {
-      clearTimeout(timeout);
       this.jobAbortControllers.delete(recoveryAbort);
     }
   }
@@ -3140,6 +3214,9 @@ function buildCliSkill(parsed, entryPath, scriptEnv) {
   if (parsed.rateLimit) {
     skill.rateLimit = parsed.rateLimit;
   }
+  if (parsed.executionTimeoutSecs !== void 0) {
+    skill.executionTimeoutSecs = parsed.executionTimeoutSecs;
+  }
   return skill;
 }
 function loadSkillsFromDir(skillsDir, options = {}) {
@@ -3917,7 +3994,10 @@ async function cmdStart(nameArg, options = {}) {
     recoveryMaxRetries: RECOVERY_MAX_RETRIES,
     recoveryIntervalSecs: RECOVERY_INTERVAL_SECS,
     network: walletNetwork,
-    solanaAddress
+    solanaAddress,
+    // Agent-level default execution budget; per-skill `max_execution_secs`
+    // overrides it. Undefined => unlimited (operator-owned, no protocol default).
+    executionTimeoutSecs: loaded.yaml.execution_timeout_secs
   };
   const rpcUrlForLog = stripRpcSecrets(process.env.SOLANA_RPC_URL ?? getRpcUrl());
   logger.debug(