@elisym/cli 0.17.2 → 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));
@@ -2366,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}`);
@@ -2406,7 +2425,6 @@ var AgentRuntime = class {
       await this.transport.sendFeedback(job, { type: "error", message: safeMessage }).catch(() => {
       });
     } finally {
-      clearTimeout(timeoutId);
       this.jobAbortControllers.delete(jobAbort);
     }
   }
@@ -2468,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(
         {
@@ -2476,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`);
@@ -2731,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 = {
@@ -2788,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);
     }
   }
@@ -3163,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 = {}) {
@@ -3940,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(