@axlsdk/axl 0.24.2 → 0.25.0

package/dist/index.d.cts

@@ -2161,6 +2161,8 @@ declare class NoConsensus extends AxlError {
 type TimeoutBreakdown = {
     /** Wall clock consumed by the operation when it timed out. */
     elapsedMs: number;
+    /** Graceful work budget consumed after human and observed governor waits. */
+    chargedMs: number;
     /** Sum of `CallTiming.queuedMs` — self-imposed rate-limiter wait. */
     queuedMs: number;
     /** Sum of `CallTiming.retryMs` — failed provider attempts and their backoff. */

package/dist/index.d.ts

@@ -2161,6 +2161,8 @@ declare class NoConsensus extends AxlError {
 type TimeoutBreakdown = {
     /** Wall clock consumed by the operation when it timed out. */
     elapsedMs: number;
+    /** Graceful work budget consumed after human and observed governor waits. */
+    chargedMs: number;
     /** Sum of `CallTiming.queuedMs` — self-imposed rate-limiter wait. */
     queuedMs: number;
     /** Sum of `CallTiming.retryMs` — failed provider attempts and their backoff. */

package/dist/index.js

@@ -111,6 +111,12 @@ function isEventStreamOverflowError(error) {
 function rethrowEventStreamOverflow(error) {
   if (isEventStreamOverflowError(error)) throw error;
 }
+function isUnrecoverableError(error) {
+  return isEventStreamOverflowError(error) || isAdmissionDeniedError(error);
+}
+function rethrowUnrecoverable(error) {
+  if (isUnrecoverableError(error)) throw error;
+}
 function preserveErrorCause(error, cause) {
   if (cause === void 0 || cause === error || "cause" in error) return error;
   Object.defineProperty(error, "cause", {
@@ -187,7 +193,7 @@ var TimeoutError = class extends AxlError {
   constructor(operation, timeoutMs, breakdown, agent2) {
     super(
       "TIMEOUT",
-      `${operation} exceeded timeout of ${timeoutMs}ms` + (breakdown ? ` (elapsed ${breakdown.elapsedMs}ms: queued ${breakdown.queuedMs}ms, retries ${breakdown.retryMs}ms, wire ${breakdown.wireMs}ms, other ${breakdown.otherMs}ms)` : "") + (agent2 ? ` for agent '${agent2}'` : "")
+      `${operation} exceeded timeout of ${timeoutMs}ms` + (breakdown ? ` (elapsed ${breakdown.elapsedMs}ms: queued ${breakdown.queuedMs}ms, retries ${breakdown.retryMs}ms, wire ${breakdown.wireMs}ms, other ${breakdown.otherMs}ms, charged ${breakdown.chargedMs}ms)` : "") + (agent2 ? ` for agent '${agent2}'` : "")
     );
     this.name = "TimeoutError";
     if (breakdown) this.breakdown = breakdown;
@@ -325,7 +331,7 @@ var sharedGuard = typeof installedGuard === "object" && installedGuard !== null
 var buildPath = typeof __AXL_BUILD_PATH__ === "string" ? __AXL_BUILD_PATH__ : "<source>";
 var thisCopy = {
   path: buildPath.startsWith("file:") ? fileURLToPath(buildPath) : buildPath,
-  version: true ? "0.24.2" : "unknown"
+  version: true ? "0.25.0" : "unknown"
 };
 function warnCrossCopy(other, joined) {
   if (other === thisCopy) return;
@@ -1219,8 +1225,7 @@ function tool(config) {
       } catch (err) {
         if (options?.signal?.aborted) options.signal.throwIfAborted();
         if (isAbortError(err)) throw err;
-        if (isAdmissionDeniedError(err)) throw err;
-        rethrowEventStreamOverflow(err);
+        rethrowUnrecoverable(err);
         lastError = err instanceof Error ? err : new Error(String(err));
         if (attempt === maxAttempts) break;
         if (retryPolicy.on && !retryPolicy.on(lastError)) {
@@ -1310,6 +1315,41 @@ var OPENAI_DEFAULT_BASE_URL = "https://api.openai.com/v1";
 var ANTHROPIC_DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 var GEMINI_DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 
+// src/ask-clock.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var askClockStorage = new AsyncLocalStorage2();
+function runWithAskClock(fn) {
+  const tracker = { pausedMs: 0, activePauses: 0 };
+  const enclosing = askClockStorage.getStore() ?? [];
+  return askClockStorage.run([...enclosing, tracker], fn);
+}
+function currentAskClock() {
+  return askClockStorage.getStore()?.at(-1);
+}
+function pausedAskClockMs(tracker, now = Date.now()) {
+  return tracker.pausedMs + (tracker.activePauses > 0 && tracker.pauseStartedAt !== void 0 ? now - tracker.pauseStartedAt : 0);
+}
+async function pauseAskClocks(wait) {
+  const trackers = askClockStorage.getStore();
+  if (!trackers || trackers.length === 0) return wait();
+  const startedAt = Date.now();
+  for (const tracker of trackers) {
+    if (tracker.activePauses++ === 0) tracker.pauseStartedAt = startedAt;
+  }
+  try {
+    return await wait();
+  } finally {
+    const finishedAt = Date.now();
+    for (const tracker of trackers) {
+      tracker.activePauses--;
+      if (tracker.activePauses === 0 && tracker.pauseStartedAt !== void 0) {
+        tracker.pausedMs += finishedAt - tracker.pauseStartedAt;
+        tracker.pauseStartedAt = void 0;
+      }
+    }
+  }
+}
+
 // src/providers/rate-limiter.ts
 function sanitizeRateLimitConfig(config) {
   const limits = {};
@@ -2372,7 +2412,7 @@ async function fetchWithRetry(input, init, opts) {
   let headersAt = 0;
   const waitSelfImposed = async (wait) => {
     const start = Date.now();
-    await wait();
+    await pauseAskClocks(wait);
     const waited = Date.now() - start;
     queuedMs += waited;
     if (dispatches > 0) queuedAfterFirstDispatchMs += waited;
@@ -8997,7 +9037,7 @@ var TranscriptionProviderRegistry = class {
 };
 
 // src/context.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 import { randomUUID } from "crypto";
 import { z, ZodError as ZodError2 } from "zod";
 
@@ -12356,8 +12396,7 @@ async function executeAcceptedTool(options) {
       }
     }
   } catch (error) {
-    rethrowEventStreamOverflow(error);
-    if (isAdmissionDeniedError(error)) throw error;
+    rethrowUnrecoverable(error);
     const abort = cancellationError(signal, error);
     if (abort !== void 0) return cancellation("handler", abort);
     return failed("handler", error, { attempts });
@@ -12530,9 +12569,8 @@ function recordToolSpanOutcome(span, outcome) {
 }
 
 // src/context.ts
-var signalStorage = new AsyncLocalStorage2();
-var hardSignalStorage = new AsyncLocalStorage2();
-var timeoutTrackerStorage = new AsyncLocalStorage2();
+var signalStorage = new AsyncLocalStorage3();
+var hardSignalStorage = new AsyncLocalStorage3();
 var MAX_TIMER_DELAY_MS = 2147483647;
 function composeAbortSignals(...signals) {
   const active = signals.filter((signal) => signal !== void 0);
@@ -12564,9 +12602,6 @@ function raceWithAbortSignal(promise, signal) {
     );
   });
 }
-function pausedHumanWaitMs(tracker, now = Date.now()) {
-  return tracker.humanWaitMs + (tracker.activeHumanWaits > 0 && tracker.humanWaitStartedAt !== void 0 ? now - tracker.humanWaitStartedAt : 0);
-}
 var DEFAULT_BRANCH_DRAIN_TIMEOUT_MS = 5e3;
 function resolveBranchDrainTimeoutMs(value) {
   const resolved = value === void 0 ? DEFAULT_BRANCH_DRAIN_TIMEOUT_MS : value;
@@ -12637,7 +12672,7 @@ function parseHumanDecision(value) {
   }
   return invalid3();
 }
-var askStorage = new AsyncLocalStorage2();
+var askStorage = new AsyncLocalStorage3();
 var inlineSchemaCache = /* @__PURE__ */ new WeakMap();
 function zodToJsonSchema(schema) {
   const cached = inlineSchemaCache.get(schema);
@@ -13574,10 +13609,7 @@ var WorkflowContext = class _WorkflowContext {
     return hardAskSignal ? hardSignalStorage.run(hardAskSignal, runWithAskSignal) : runWithAskSignal();
   }
   async executeAgentCall(agent2, input, options, handoffMessages, usageCapture, sessionHistory = normalizeSessionHistory(this.sessionHistory)) {
-    const tracker = { humanWaitMs: 0, activeHumanWaits: 0 };
-    const enclosing = timeoutTrackerStorage.getStore() ?? [];
-    return timeoutTrackerStorage.run(
-      [...enclosing, tracker],
+    return runWithAskClock(
       () => this.executeAgentCallImpl(
         agent2,
         input,
@@ -13852,7 +13884,7 @@ ${appendedSchemaText}`;
       );
     }
     const startTime = Date.now();
-    const timeoutTracker = timeoutTrackerStorage.getStore()?.at(-1);
+    const askClock = currentAskClock();
     const timingTotals = { turns: 0, queuedMs: 0, retryMs: 0, wireMs: 0 };
     const currentMessages = [...messages];
     let turns = 0;
@@ -13869,13 +13901,16 @@ ${appendedSchemaText}`;
     while (turns < maxTurns) {
       this.currentSignal?.throwIfAborted();
       const now = Date.now();
-      const elapsedMs = now - startTime - (timeoutTracker ? pausedHumanWaitMs(timeoutTracker, now) : 0);
-      if (elapsedMs > timeoutMs) {
+      const elapsedMs = now - startTime;
+      const pausedMs = askClock ? pausedAskClockMs(askClock, now) : 0;
+      const chargedMs = Math.max(0, elapsedMs - Math.min(pausedMs, Math.max(0, elapsedMs)));
+      if (chargedMs > timeoutMs) {
         throw new TimeoutError(
           "ctx.ask()",
           timeoutMs,
           timingTotals.turns > 0 ? {
             elapsedMs,
+            chargedMs,
             queuedMs: timingTotals.queuedMs,
             retryMs: timingTotals.retryMs,
             wireMs: timingTotals.wireMs,
@@ -14623,7 +14658,8 @@ ${appendedSchemaText}`;
             metadata: this.metadata
           });
         } catch (err) {
-          rethrowEventStreamOverflow(err);
+          rethrowUnrecoverable(err);
+          if (this.currentSignal?.aborted) throw err;
           validateErr = err;
           const reason = err instanceof Error ? err.message : String(err);
           validateResult = { valid: false, reason: `Validator error: ${reason}` };
@@ -15214,15 +15250,13 @@ ${summaryResponse.content}`
               reject(new QuorumNotMet(quorum, successCount, results));
             }
           }).catch((err) => {
-            if (isEventStreamOverflowError(err)) {
-              if (!settled) {
-                settled = true;
-                controller.abort();
-                reject(err);
-              }
+            if (settled) return;
+            if (isUnrecoverableError(err) || parentSignal2?.aborted) {
+              settled = true;
+              controller.abort();
+              reject(err);
               return;
             }
-            if (settled) return;
             const isAbort = err instanceof DOMException && err.name === "AbortError";
             if (isAbort) {
               completedCount++;
@@ -15245,7 +15279,8 @@ ${summaryResponse.content}`
     const parentSignal = this.currentSignal;
     const promises = Array.from({ length: n }, (_, i) => {
       const run = () => fn(i).then((value) => ({ ok: true, value })).catch((err) => {
-        rethrowEventStreamOverflow(err);
+        rethrowUnrecoverable(err);
+        if (parentSignal?.aborted) throw err;
         return {
           ok: false,
           error: err instanceof Error ? err.message : String(err)
@@ -15369,6 +15404,7 @@ ${summaryResponse.content}`
   async verify(fn, schema, options) {
     const maxRetries = options?.retries ?? 3;
     let lastRetry = void 0;
+    const scopeSignal = this.currentSignal;
     const emitVerifyOutcome = (passed, attempts, lastError) => {
       this.emitEvent({
         type: "verify",
@@ -15391,25 +15427,24 @@ ${summaryResponse.content}`
           try {
             validateResult = await options.validate(parsed, { metadata: this.metadata });
           } catch (err) {
-            rethrowEventStreamOverflow(err);
+            rethrowUnrecoverable(err);
+            if (scopeSignal?.aborted) throw err;
             const reason = err instanceof Error ? err.message : String(err);
             validateResult = { valid: false, reason: `Validator error: ${reason}` };
           }
           if (!validateResult.valid) {
+            scopeSignal?.throwIfAborted();
             const errorMsg = validateResult.reason ?? "Validation failed";
             lastRetry = { error: errorMsg, output: rawOutput, parsed };
-            if (attempt === maxRetries) {
-              emitVerifyOutcome(false, attempt + 1, errorMsg);
-              if (options?.fallback !== void 0) return options.fallback;
-              throw new ValidationError(parsed, errorMsg, maxRetries);
-            }
+            if (attempt === maxRetries) throw new ValidationError(parsed, errorMsg, maxRetries);
             continue;
           }
         }
         emitVerifyOutcome(true, attempt + 1);
         return parsed;
       } catch (err) {
-        rethrowEventStreamOverflow(err);
+        rethrowUnrecoverable(err);
+        if (scopeSignal?.aborted) throw err;
         if (err instanceof ValidationError) {
           lastRetry = {
             error: err.reason,
@@ -15476,7 +15511,8 @@ ${summaryResponse.content}`
         const unpriced = this.budgetContext.unpriced;
         return { value, budgetExceeded: exceeded, totalCost, unpriced };
       } catch (err) {
-        rethrowEventStreamOverflow(err);
+        rethrowUnrecoverable(err);
+        if (parentSignal?.aborted) throw err;
         if (this.budgetContext.exceeded) {
           return {
             value: null,
@@ -15485,14 +15521,6 @@ ${summaryResponse.content}`
             unpriced: this.budgetContext.unpriced
           };
         }
-        if (err instanceof DOMException && err.name === "AbortError" && controller) {
-          return {
-            value: null,
-            budgetExceeded: true,
-            totalCost: this.budgetContext.totalCost,
-            unpriced: this.budgetContext.unpriced
-          };
-        }
         throw err;
       } finally {
         if (parentBudget) {
@@ -15608,7 +15636,8 @@ ${summaryResponse.content}`
                   return;
                 }
               } catch (err) {
-                rethrowEventStreamOverflow(err);
+                rethrowUnrecoverable(err);
+                if (parentSignal?.aborted) throw err;
                 remaining--;
                 lastError = err instanceof Error ? err : new Error(`Validator error: ${String(err)}`);
                 if (remaining === 0 && !settled) {
@@ -15628,7 +15657,7 @@ ${summaryResponse.content}`
           controller.abort();
           resolve2(value);
         }).catch((err) => {
-          if (isEventStreamOverflowError(err)) {
+          if (isUnrecoverableError(err)) {
             if (!settled) {
               settled = true;
               controller.abort();
@@ -15637,6 +15666,12 @@ ${summaryResponse.content}`
             throw err;
           }
           if (settled) return;
+          if (parentSignal?.aborted) {
+            settled = true;
+            controller.abort();
+            reject(err);
+            return;
+          }
           if (err instanceof DOMException && err.name === "AbortError") {
             remaining--;
             if (remaining === 0 && !settled) {
@@ -15695,7 +15730,7 @@ ${summaryResponse.content}`
             results[idx] = { ok: true, value };
             successCount++;
           } catch (err) {
-            if (isEventStreamOverflowError(err)) {
+            if (isUnrecoverableError(err)) {
               settled = true;
               controller?.abort();
               reject(err);
@@ -15704,6 +15739,12 @@ ${summaryResponse.content}`
             if (settled) {
               return;
             }
+            if (parentSignal?.aborted) {
+              settled = true;
+              controller?.abort();
+              reject(err);
+              return;
+            }
             if (err instanceof DOMException && err.name === "AbortError" && controller?.signal.aborted) {
               completedCount++;
               return;
@@ -15739,12 +15780,7 @@ ${summaryResponse.content}`
   }
   // ── ctx.awaitHuman() ──────────────────────────────────────────────────
   async awaitHuman(options) {
-    const trackers = timeoutTrackerStorage.getStore();
-    const startedAt = Date.now();
-    for (const tracker of trackers ?? []) {
-      if (tracker.activeHumanWaits++ === 0) tracker.humanWaitStartedAt = startedAt;
-    }
-    try {
+    return pauseAskClocks(async () => {
       if (this.spanManager) {
         return await this.spanManager.withSpanAsync(
           "axl.ctx.awaitHuman",
@@ -15761,16 +15797,7 @@ ${summaryResponse.content}`
         );
       }
       return await this._awaitHumanImpl(options);
-    } finally {
-      const finishedAt = Date.now();
-      for (const tracker of trackers ?? []) {
-        tracker.activeHumanWaits--;
-        if (tracker.activeHumanWaits === 0 && tracker.humanWaitStartedAt !== void 0) {
-          tracker.humanWaitMs += finishedAt - tracker.humanWaitStartedAt;
-          tracker.humanWaitStartedAt = void 0;
-        }
-      }
-    }
+    });
   }
   async _awaitHumanImpl(options) {
     const branchSignal = this.currentSignal;
@@ -16767,7 +16794,7 @@ function workflow(config) {
 // src/runtime.ts
 import { EventEmitter as EventEmitter2 } from "events";
 import { randomUUID as randomUUID4 } from "crypto";
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "async_hooks";
 import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { dirname } from "path";
 
@@ -18956,7 +18983,7 @@ function assertNoRemovedObservationCallbacks(options) {
     `runtime.createContext() no longer accepts ${removed.join(", ")}. Observe ctx.events or use runtime.stream() instead. See docs/migration/stream-first-observation.md.`
   );
 }
-var costScopeStorage = new AsyncLocalStorage3();
+var costScopeStorage = new AsyncLocalStorage4();
 function forwardAbortSignal(external, internal) {
   if (!external) return () => {
   };