tjs-lang 0.8.0 → 0.8.2

package/src/vm/vm.ts

@@ -4,6 +4,7 @@ import {
   type RunResult,
   type RuntimeContext,
   type CostOverride,
+  type TimeoutOverride,
   coreAtoms,
   AgentError,
   isProcedureToken,
@@ -13,16 +14,49 @@ import { TypedBuilder, type BaseNode, type BuilderType } from '../builder'
 import { validate } from 'tosijs-schema'
 import { transpile } from '../lang/core'
 
-/** Default timeout multiplier: milliseconds per fuel unit */
-const FUEL_TO_MS = 10 // 1000 fuel = 10 seconds
+/**
+ * Floor for the run-level default timeout. The actual default is derived from
+ * the registered atoms (slowest atom × 2 — see `defaultRunTimeout`), but never
+ * drops below this for a VM whose atoms are all fast.
+ */
+const MIN_DEFAULT_RUN_TIMEOUT_MS = 60_000
 
 export class AgentVM<M extends Record<string, Atom<any, any>>> {
   readonly atoms: typeof coreAtoms & M
 
+  private _defaultRunTimeout?: number
+
   constructor(customAtoms: M = {} as M) {
     this.atoms = { ...coreAtoms, ...customAtoms }
   }
 
+  /**
+   * Default run-level wall-clock timeout when `run()` is given no explicit
+   * `timeoutMs`. Derived as `max(per-atom timeoutMs) × 2` over the registered
+   * atoms (with headroom for an agent that chains a couple of slow calls), so
+   * the run-level backstop can never be shorter than the slowest single atom's
+   * own budget — otherwise that per-atom budget would be dead config (e.g.
+   * `llmVision`/`llmPredictBattery` are 120s; a fixed 60s run default would kill
+   * them mid-call). Atoms with `timeoutMs: 0` (no timeout, e.g. `seq`) are
+   * excluded; the result is floored at {@link MIN_DEFAULT_RUN_TIMEOUT_MS}.
+   * Self-adjusting: registering a slower custom atom raises the default.
+   */
+  get defaultRunTimeout(): number {
+    if (this._defaultRunTimeout === undefined) {
+      let slowest = 0
+      for (const atom of Object.values(this.atoms)) {
+        // undefined timeoutMs means the per-atom default (1000ms); 0 means none.
+        const t = (atom as any).timeoutMs ?? 1000
+        if (t > 0 && t > slowest) slowest = t
+      }
+      this._defaultRunTimeout = Math.max(
+        MIN_DEFAULT_RUN_TIMEOUT_MS,
+        slowest * 2
+      )
+    }
+    return this._defaultRunTimeout
+  }
+
   get builder(): BuilderType<typeof coreAtoms & M> {
     return new TypedBuilder(this.atoms) as any
   }
@@ -77,9 +111,10 @@ export class AgentVM<M extends Record<string, Atom<any, any>>> {
       fuel?: number
       capabilities?: Capabilities
       trace?: boolean
-      timeoutMs?: number // Override automatic timeout (fuel * FUEL_TO_MS)
+      timeoutMs?: number // Wall-clock cap on the whole run (default: slowest atom × 2, min 60s — see defaultRunTimeout)
       signal?: AbortSignal // External abort signal (e.g., from caller)
       costOverrides?: Record<string, CostOverride> // Per-atom fuel cost overrides
+      timeoutOverrides?: Record<string, TimeoutOverride> // Per-atom timeout overrides (ms, 0 disables)
       context?: Record<string, any> // Request-scoped metadata (auth, permissions, etc.)
     } = {}
   ): Promise<RunResult> {
@@ -94,7 +129,9 @@ export class AgentVM<M extends Record<string, Atom<any, any>>> {
         try {
           ast = transpile(astOrToken).ast as BaseNode
         } catch (e: any) {
-          throw new Error(`AJS transpilation failed: ${e.message}`)
+          throw new Error(`AJS transpilation failed: ${e.message}`, {
+            cause: e,
+          })
         }
       }
     } else {
@@ -103,9 +140,10 @@ export class AgentVM<M extends Record<string, Atom<any, any>>> {
 
     const startFuel = options.fuel ?? 1000
 
-    // Calculate timeout from fuel budget (generous: 10ms per fuel unit)
-    // Can be overridden with explicit timeoutMs option
-    const timeoutMs = options.timeoutMs ?? startFuel * FUEL_TO_MS
+    // Run-level wall-clock timeout. Agents are typically IO-bound; the default
+    // is derived from the registered atoms (slowest × 2) so it always covers the
+    // slowest atom's own budget. See `defaultRunTimeout`.
+    const timeoutMs = options.timeoutMs ?? this.defaultRunTimeout
 
     // Default Capabilities
     const capabilities = options.capabilities ?? {}
@@ -158,8 +196,10 @@ export class AgentVM<M extends Record<string, Atom<any, any>>> {
       output: undefined,
       signal: controller.signal,
       costOverrides: options.costOverrides,
+      timeoutOverrides: options.timeoutOverrides,
       context: options.context,
       warnings, // Shared warnings array
+      helpers: (ast as any).helpers, // Local helper bodies, called by name via callLocal
     }
 
     if (options.trace) {
@@ -195,7 +235,7 @@ export class AgentVM<M extends Record<string, Atom<any, any>>> {
           controller.signal.addEventListener('abort', () => {
             reject(
               new Error(
-                `Execution timeout after ${timeoutMs}ms (fuel: ${startFuel}). Consider increasing fuel or optimizing your agent.`
+                `Execution timeout after ${timeoutMs}ms. Pass a higher \`timeoutMs\` to vm.run() or set per-atom \`timeoutOverrides\` for slow IO atoms.`
               )
             )
           })
@@ -203,7 +243,7 @@ export class AgentVM<M extends Record<string, Atom<any, any>>> {
           if (controller.signal.aborted) {
             reject(
               new Error(
-                `Execution timeout after ${timeoutMs}ms (fuel: ${startFuel}). Consider increasing fuel or optimizing your agent.`
+                `Execution timeout after ${timeoutMs}ms. Pass a higher \`timeoutMs\` to vm.run() or set per-atom \`timeoutOverrides\` for slow IO atoms.`
               )
             )
           }
@@ -217,7 +257,7 @@ export class AgentVM<M extends Record<string, Atom<any, any>>> {
         controller.signal.aborted
       ) {
         ctx.error = new AgentError(
-          `Execution timeout after ${timeoutMs}ms (fuel: ${startFuel}). Consider increasing fuel or optimizing your agent.`,
+          `Execution timeout after ${timeoutMs}ms. Pass a higher \`timeoutMs\` to vm.run() or set per-atom \`timeoutOverrides\` for slow IO atoms.`,
           'vm.run'
         )
       } else {