@axlsdk/axl 0.24.2 → 0.25.0

package/dist/index.cjs

@@ -343,6 +343,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", {
@@ -419,7 +425,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;
@@ -557,7 +563,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:") ? (0, import_node_url.fileURLToPath)(buildPath) : buildPath,
-  version: true ? "0.24.2" : "unknown"
+  version: true ? "0.25.0" : "unknown"
 };
 function warnCrossCopy(other, joined) {
   if (other === thisCopy) return;
@@ -1451,8 +1457,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)) {
@@ -1542,6 +1547,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
+var import_node_async_hooks2 = require("async_hooks");
+var askClockStorage = new import_node_async_hooks2.AsyncLocalStorage();
+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 = {};
@@ -2604,7 +2644,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;
@@ -9229,7 +9269,7 @@ var TranscriptionProviderRegistry = class {
 };
 
 // src/context.ts
-var import_node_async_hooks2 = require("async_hooks");
+var import_node_async_hooks3 = require("async_hooks");
 var import_node_crypto = require("crypto");
 var import_zod2 = require("zod");
 
@@ -12588,8 +12628,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 });
@@ -12762,9 +12801,8 @@ function recordToolSpanOutcome(span, outcome) {
 }
 
 // src/context.ts
-var signalStorage = new import_node_async_hooks2.AsyncLocalStorage();
-var hardSignalStorage = new import_node_async_hooks2.AsyncLocalStorage();
-var timeoutTrackerStorage = new import_node_async_hooks2.AsyncLocalStorage();
+var signalStorage = new import_node_async_hooks3.AsyncLocalStorage();
+var hardSignalStorage = new import_node_async_hooks3.AsyncLocalStorage();
 var MAX_TIMER_DELAY_MS = 2147483647;
 function composeAbortSignals(...signals) {
   const active = signals.filter((signal) => signal !== void 0);
@@ -12796,9 +12834,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;
@@ -12869,7 +12904,7 @@ function parseHumanDecision(value) {
   }
   return invalid3();
 }
-var askStorage = new import_node_async_hooks2.AsyncLocalStorage();
+var askStorage = new import_node_async_hooks3.AsyncLocalStorage();
 var inlineSchemaCache = /* @__PURE__ */ new WeakMap();
 function zodToJsonSchema(schema) {
   const cached = inlineSchemaCache.get(schema);
@@ -13806,10 +13841,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,
@@ -14084,7 +14116,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;
@@ -14101,13 +14133,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,
@@ -14855,7 +14890,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}` };
@@ -15446,15 +15482,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++;
@@ -15477,7 +15511,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)
@@ -15601,6 +15636,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",
@@ -15623,25 +15659,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,
@@ -15708,7 +15743,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,
@@ -15717,14 +15753,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) {
@@ -15840,7 +15868,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) {
@@ -15860,7 +15889,7 @@ ${summaryResponse.content}`
           controller.abort();
           resolve2(value);
         }).catch((err) => {
-          if (isEventStreamOverflowError(err)) {
+          if (isUnrecoverableError(err)) {
             if (!settled) {
               settled = true;
               controller.abort();
@@ -15869,6 +15898,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) {
@@ -15927,7 +15962,7 @@ ${summaryResponse.content}`
             results[idx] = { ok: true, value };
             successCount++;
           } catch (err) {
-            if (isEventStreamOverflowError(err)) {
+            if (isUnrecoverableError(err)) {
               settled = true;
               controller?.abort();
               reject(err);
@@ -15936,6 +15971,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;
@@ -15971,12 +16012,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",
@@ -15993,16 +16029,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;
@@ -16999,7 +17026,7 @@ function workflow(config) {
 // src/runtime.ts
 var import_node_events2 = require("events");
 var import_node_crypto4 = require("crypto");
-var import_node_async_hooks3 = require("async_hooks");
+var import_node_async_hooks4 = require("async_hooks");
 var import_node_fs3 = require("fs");
 var import_node_path3 = require("path");
 
@@ -19179,7 +19206,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 import_node_async_hooks3.AsyncLocalStorage();
+var costScopeStorage = new import_node_async_hooks4.AsyncLocalStorage();
 function forwardAbortSignal(external, internal) {
   if (!external) return () => {
   };