@axlsdk/axl 0.10.4 → 0.11.1

package/dist/index.cjs

@@ -2281,6 +2281,14 @@ var WorkflowContext = class _WorkflowContext {
   input;
   executionId;
   metadata;
+  /**
+   * Total cost accumulated by agent calls in this context.
+   * Inside a `ctx.budget()` block, returns only that block's cost.
+   * After the block completes, the nested cost is rolled up into the parent total.
+   */
+  get totalCost() {
+    return this.budgetContext?.totalCost ?? 0;
+  }
   config;
   providerRegistry;
   sessionHistory;
@@ -3780,6 +3788,11 @@ ${summaryResponse.content}`
       });
       return decision2;
     }
+    if (!this.pendingDecisions) {
+      throw new Error(
+        "Tool requires approval but no approval handler is configured. Provide awaitHumanHandler to createContext() or use runtime.execute() with workflow infrastructure."
+      );
+    }
     if (this.stateStore) {
       await this.stateStore.savePendingDecision(this.executionId, {
         executionId: this.executionId,
@@ -3805,7 +3818,7 @@ ${summaryResponse.content}`
       data: { event: "await_human", channel: options.channel, prompt: options.prompt }
     });
     const decision = await new Promise((resolve) => {
-      this.pendingDecisions?.set(this.executionId, resolve);
+      this.pendingDecisions.set(this.executionId, resolve);
     });
     if (this.stateStore) {
       await this.stateStore.saveExecutionState(this.executionId, {
@@ -4023,6 +4036,7 @@ function workflow(config) {
 // src/runtime.ts
 var import_node_events2 = require("events");
 var import_node_crypto2 = require("crypto");
+var import_node_async_hooks2 = require("async_hooks");
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
 
@@ -5242,6 +5256,7 @@ function hashInput(input) {
   }
   return (hash >>> 0).toString(16);
 }
+var costScopeStorage = new import_node_async_hooks2.AsyncLocalStorage();
 var AxlRuntime = class extends import_node_events2.EventEmitter {
   config;
   workflows = /* @__PURE__ */ new Map();
@@ -5387,8 +5402,14 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
           "axl-eval is required for AxlRuntime.runRegisteredEval(). Install it with: npm install @axlsdk/eval"
         );
       }
-      const executeFn = entry.executeWorkflow;
-      return runEvalFn(entry.config, executeFn, void 0, this);
+      const originalExecuteFn = entry.executeWorkflow;
+      const wrappedExecuteFn = async (input, runtime) => {
+        const { result, cost: trackedCost } = await this.trackCost(async () => {
+          return originalExecuteFn(input, runtime);
+        });
+        return { output: result.output, cost: result.cost ?? trackedCost };
+      };
+      return runEvalFn(entry.config, wrappedExecuteFn, void 0, this);
     }
     return this.eval(
       entry.config
@@ -5399,21 +5420,38 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
     return [...this.executions.values()];
   }
   /**
-   * Create a lightweight WorkflowContext for ad-hoc use (tool testing, prototyping).
-   * The context has access to the runtime's providers, state store, and MCP manager
-   * but no session history, streaming callbacks, or budget tracking.
+   * Create a WorkflowContext for ad-hoc use (evals, tool testing, prototyping).
+   * The context has access to the runtime's providers, state store, MCP manager,
+   * and automatically emits trace events and tracks cost.
    */
   createContext(options) {
+    const executionId = (0, import_node_crypto2.randomUUID)();
+    const budgetLimit = options?.budget ? parseCost(options.budget) : Infinity;
+    this.registerWithCostScope(executionId);
     return new WorkflowContext({
       input: void 0,
-      executionId: (0, import_node_crypto2.randomUUID)(),
+      executionId,
       metadata: options?.metadata,
       config: this.config,
       providerRegistry: this.providerRegistry,
       stateStore: this.stateStore,
       mcpManager: this.mcpManager,
       spanManager: this.spanManager,
-      memoryManager: this.memoryManager
+      memoryManager: this.memoryManager,
+      sessionHistory: options?.sessionHistory,
+      signal: options?.signal,
+      onToken: options?.onToken,
+      awaitHumanHandler: options?.awaitHumanHandler,
+      onTrace: (event) => {
+        this.emit("trace", event);
+        this.outputTraceEvent(event);
+      },
+      budgetContext: {
+        totalCost: 0,
+        limit: budgetLimit,
+        exceeded: false,
+        policy: "finish_and_stop"
+      }
     });
   }
   /** Register a custom provider instance. */
@@ -5432,6 +5470,7 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
     const executionId = (0, import_node_crypto2.randomUUID)();
     const controller = new AbortController();
     this.abortControllers.set(executionId, controller);
+    this.registerWithCostScope(executionId);
     const execInfo = {
       executionId,
       workflow: name,
@@ -5476,7 +5515,13 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
       mcpManager: this.mcpManager,
       memoryManager: this.memoryManager,
       resumeMode: !!options?.metadata?.resumeMode,
-      spanManager: this.spanManager
+      spanManager: this.spanManager,
+      budgetContext: {
+        totalCost: 0,
+        limit: Infinity,
+        exceeded: false,
+        policy: "finish_and_stop"
+      }
     });
     ctx.log("workflow_start", { workflow: name, executionId });
     return this.spanManager.withSpanAsync(
@@ -5531,6 +5576,7 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
       const executionId = (0, import_node_crypto2.randomUUID)();
       this.abortControllers.set(executionId, controller);
       const sessionHistory = options?.metadata?.sessionHistory ?? void 0;
+      this.registerWithCostScope(executionId);
       execInfo = {
         executionId,
         workflow: name,
@@ -5621,7 +5667,13 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
         mcpManager: this.mcpManager,
         memoryManager: this.memoryManager,
         resumeMode: !!options?.metadata?.resumeMode,
-        spanManager: this.spanManager
+        spanManager: this.spanManager,
+        budgetContext: {
+          totalCost: 0,
+          limit: Infinity,
+          exceeded: false,
+          policy: "finish_and_stop"
+        }
       });
       return this.spanManager.withSpanAsync(
         "axl.workflow.execute",
@@ -5793,28 +5845,21 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
    * @see Spec Section 13.5
    */
   async eval(config) {
-    let runEval;
+    let runEvalFn;
     try {
-      ({ runEval } = await import("@axlsdk/eval"));
+      ({ runEval: runEvalFn } = await import("@axlsdk/eval"));
     } catch {
       throw new Error(
         "axl-eval is required for AxlRuntime.eval(). Install it with: npm install @axlsdk/eval"
       );
     }
     const executeWorkflow = async (input) => {
-      let cost = 0;
-      const costListener = (event) => {
-        if (event.cost) cost += event.cost;
-      };
-      this.on("trace", costListener);
-      try {
-        const output = await this.execute(config.workflow, input);
-        return { output, cost };
-      } finally {
-        this.off("trace", costListener);
-      }
+      const { result, cost } = await this.trackCost(async () => {
+        return this.execute(config.workflow, input);
+      });
+      return { output: result, cost };
     };
-    return runEval(config, executeWorkflow, void 0, this);
+    return runEvalFn(config, executeWorkflow, void 0, this);
   }
   /**
    * Compare two evaluation results to detect regressions and improvements.
@@ -5833,6 +5878,46 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
     }
     return evalCompareFn(baseline, candidate);
   }
+  /**
+   * Track cost across any runtime operations within the given function.
+   * Uses AsyncLocalStorage to scope cost attribution to specific execution IDs,
+   * making it correct with concurrent calls.
+   *
+   * Works with both `createContext()` and `execute()` calls inside `fn`.
+   */
+  async trackCost(fn) {
+    const parentScope = costScopeStorage.getStore();
+    const scope = {
+      totalCost: 0,
+      trackedIds: /* @__PURE__ */ new Set(),
+      parent: parentScope
+    };
+    const costListener = (event) => {
+      if (event.cost && scope.trackedIds.has(event.executionId)) {
+        scope.totalCost += event.cost;
+      }
+    };
+    this.setMaxListeners(this.getMaxListeners() + 1);
+    this.on("trace", costListener);
+    try {
+      const result = await costScopeStorage.run(scope, fn);
+      return { result, cost: scope.totalCost };
+    } finally {
+      this.off("trace", costListener);
+      this.setMaxListeners(this.getMaxListeners() - 1);
+    }
+  }
+  /** Register an execution ID with the active cost scope for trackCost() attribution. */
+  registerWithCostScope(executionId) {
+    const costScope = costScopeStorage.getStore();
+    if (costScope) {
+      let scope = costScope;
+      while (scope) {
+        scope.trackedIds.add(executionId);
+        scope = scope.parent;
+      }
+    }
+  }
   /**
    * Handle trace event output based on configuration.
    *