@axlsdk/axl 0.23.0 → 0.23.2

package/dist/index.js

@@ -172,15 +172,22 @@ var NoConsensus = class extends AxlError {
 var TimeoutError = class extends AxlError {
   /** Latency attribution for the timed-out operation, when measurable. */
   breakdown;
-  constructor(operation, timeoutMs, breakdown) {
+  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)` : "")
+      `${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}'` : "")
     );
     this.name = "TimeoutError";
     if (breakdown) this.breakdown = breakdown;
   }
 };
+var StallTimeoutError = class extends TimeoutError {
+  constructor(operation, timeoutMs, agent2) {
+    super(operation, timeoutMs, void 0, agent2);
+    this.name = "StallTimeoutError";
+    this.message = `${operation} provider request stalled for ${timeoutMs}ms` + (agent2 ? ` for agent '${agent2}'` : "");
+  }
+};
 function formatBudgetCost(cost) {
   if (Number.isNaN(cost)) return "$NaN";
   if (cost === Infinity) return "$Infinity";
@@ -853,6 +860,7 @@ async function fetchWithRetry(input, init, opts) {
             message: err instanceof Error ? err.message : String(err)
           });
         }
+        observer?.onRetry?.(attempt + 1, Date.now());
         await sleep2(jitter(BASE_DELAY_MS * 2 ** attempt), init?.signal ?? void 0);
         continue;
       }
@@ -868,6 +876,7 @@ async function fetchWithRetry(input, init, opts) {
       }
       const retryAfterMs = parseRetryAfter(res.headers);
       const baseDelay = retryAfterMs !== void 0 ? Math.min(retryAfterMs, MAX_BACKOFF_MS) : BASE_DELAY_MS * 2 ** attempt;
+      observer?.onRetry?.(attempt + 1, Date.now());
       await sleep2(jitter(baseDelay), init?.signal ?? void 0);
     }
   } finally {
@@ -877,12 +886,23 @@ async function fetchWithRetry(input, init, opts) {
 
 // src/providers/call-timing.ts
 var CallTimingRecorder = class {
+  constructor(requestLifecycle) {
+    this.requestLifecycle = requestLifecycle;
+  }
   fetchTiming;
   firstTokenAt;
+  /** Consumer suspension after pre-content chunks (for example, tool deltas). */
+  preFirstTokenConsumerMs = 0;
   /** Cumulative time awaiting `reader.read()`, i.e. transport, not consumer. */
   readWaitMs = 0;
   /** Pass as `timing` in the `fetchWithRetry` options object. */
   observer = {
+    onDispatch: () => {
+      this.requestLifecycle?.onDispatch?.();
+    },
+    onRetry: () => {
+      this.requestLifecycle?.onRetry?.();
+    },
     onComplete: (timing) => {
       this.fetchTiming = timing;
     }
@@ -904,6 +924,12 @@ var CallTimingRecorder = class {
   markFirstToken() {
     this.firstTokenAt ??= Date.now();
   }
+  /** Exclude backpressure after a pre-content yield from first-content latency. */
+  recordPreFirstTokenConsumerPause(startedAt) {
+    if (this.firstTokenAt === void 0) {
+      this.preFirstTokenConsumerMs += Math.max(0, Date.now() - startedAt);
+    }
+  }
   /**
    * Timing for a non-streaming call. Call once the response body is parsed.
    *
@@ -927,13 +953,17 @@ var CallTimingRecorder = class {
     const t = this.fetchTiming;
     if (!t) return void 0;
     const ttfbMs = Math.max(0, t.headersAt - t.dispatchedAt);
+    const firstTokenMs = this.firstTokenAt !== void 0 ? Math.max(0, this.firstTokenAt - t.dispatchedAt - this.preFirstTokenConsumerMs) : void 0;
     return {
       queuedMs: t.queuedMs,
       attempts: t.attempts,
       retryMs: t.retryMs,
       ttfbMs,
-      ...this.firstTokenAt !== void 0 ? { firstTokenMs: Math.max(0, this.firstTokenAt - t.dispatchedAt) } : {},
-      wireMs: ttfbMs + this.readWaitMs
+      ...firstTokenMs !== void 0 ? { firstTokenMs } : {},
+      // Parsing and generator scheduling can happen after the first read has
+      // settled. Include that pre-first-token gap so the public relationship
+      // stays intuitive, without charging pauses after any chunk is yielded.
+      wireMs: Math.max(ttfbMs + this.readWaitMs, firstTokenMs ?? 0)
     };
   }
 };
@@ -946,7 +976,9 @@ async function* withCallTiming(recorder, source) {
       const timing = recorder.streamTiming();
       yield timing ? { ...chunk, timing } : chunk;
     } else {
+      const yieldedAt = Date.now();
       yield chunk;
+      recorder.recordPreFirstTokenConsumerPause(yieldedAt);
     }
   }
 }
@@ -956,9 +988,6 @@ function withChatTiming(recorder, response) {
 }
 
 // src/providers/rate-limiter.ts
-function abortError() {
-  return Object.assign(new Error("The operation was aborted"), { name: "AbortError" });
-}
 var RateLimiter = class {
   maxConcurrent;
   minIntervalMs;
@@ -1007,11 +1036,11 @@ var RateLimiter = class {
    * With `acquireTimeoutMs`, a waiter that sits in the queue too long rejects.
    */
   acquire(signal) {
-    if (signal?.aborted) return Promise.reject(abortError());
+    if (signal?.aborted) return Promise.reject(signal.reason);
     return new Promise((resolve2, reject) => {
       const waiter = { resolve: resolve2, reject, signal };
       if (signal) {
-        waiter.onAbort = () => this.settleWaiter(waiter, abortError());
+        waiter.onAbort = () => this.settleWaiter(waiter, signal.reason);
         signal.addEventListener("abort", waiter.onAbort, { once: true });
       }
       if (this.acquireTimeoutMs != null) {
@@ -1311,6 +1340,7 @@ function normalizeMessageContent(content) {
 }
 var OpenAICompatibleProvider = class {
   name;
+  reportsRequestLifecycle = true;
   inputCapabilities(model) {
     return this.name === "openrouter" && model.trim().length > 0 ? { image: { sources: ["url", "bytes", "base64"] } } : {};
   }
@@ -1407,7 +1437,7 @@ var OpenAICompatibleProvider = class {
   async chat(messages, options) {
     const headers = this.buildHeaders(await this.resolveKey());
     const body = this.buildRequestBody(messages, options, false);
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/chat/completions`,
       {
@@ -1438,7 +1468,7 @@ var OpenAICompatibleProvider = class {
   async *stream(messages, options) {
     const headers = this.buildHeaders(await this.resolveKey());
     const body = this.buildRequestBody(messages, options, true);
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/chat/completions`,
       {
@@ -2346,6 +2376,7 @@ function responseImageParts(parts) {
 }
 var OpenAIResponsesProvider = class {
   name = "openai-responses";
+  reportsRequestLifecycle = true;
   inputCapabilities(model) {
     return model.trim().length > 0 ? { image: { sources: ["url", "bytes", "base64", "provider-file"] } } : {};
   }
@@ -2432,7 +2463,7 @@ var OpenAIResponsesProvider = class {
   async chat(messages, options) {
     const headers = this.buildHeaders(await this.resolveKey());
     const body = this.buildRequestBody(messages, options, false);
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/responses`,
       {
@@ -2467,7 +2498,7 @@ var OpenAIResponsesProvider = class {
   async *stream(messages, options) {
     const headers = this.buildHeaders(await this.resolveKey());
     const body = this.buildRequestBody(messages, options, true);
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/responses`,
       {
@@ -3271,6 +3302,7 @@ function mergeAnthropicUsage(initial, update) {
 }
 var AnthropicProvider = class {
   name = "anthropic";
+  reportsRequestLifecycle = true;
   /** Report a clamped `effort`. Anthropic clamps to each model's supported
    *  `output_config.effort` levels, and models that always think fall back to
    *  adaptive `'low'` when asked to disable thinking. Only reported when the
@@ -3388,7 +3420,7 @@ var AnthropicProvider = class {
     );
     const body = this.buildRequestBody(messages, options, false);
     const pricingContext = pricingContextFromBody(body);
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/messages`,
       {
@@ -3424,7 +3456,7 @@ var AnthropicProvider = class {
     );
     const body = this.buildRequestBody(messages, options, true);
     const pricingContext = pricingContextFromBody(body);
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/messages`,
       {
@@ -4251,6 +4283,7 @@ function resolveGeminiThinking(model, resolved) {
 }
 var GeminiProvider = class {
   name = "google";
+  reportsRequestLifecycle = true;
   inputCapabilities(model) {
     return model.trim().length > 0 ? { image: { sources: ["bytes", "base64", "provider-file"] } } : {};
   }
@@ -4368,7 +4401,7 @@ var GeminiProvider = class {
     const pricingContext = this.pricingContext(this.requestModel(options), body);
     this.assertSafeGemini3Continuation(messages, pricingContext.model);
     const headers = this.buildHeaders(await this.resolveKey());
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/models/${pricingContext.model}:generateContent`,
       {
@@ -4406,7 +4439,7 @@ var GeminiProvider = class {
     const pricingContext = this.pricingContext(this.requestModel(options), body);
     this.assertSafeGemini3Continuation(messages, pricingContext.model);
     const headers = this.buildHeaders(await this.resolveKey());
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/models/${pricingContext.model}:streamGenerateContent?alt=sse`,
       {
@@ -4443,7 +4476,7 @@ var GeminiProvider = class {
     this.assertSafeInteractionOptions(options);
     const body = this.buildInteractionRequestBody(messages, options, false);
     const headers = this.buildHeaders(await this.resolveKey());
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/interactions`,
       { method: "POST", headers, body: JSON.stringify(body), signal: options.signal },
@@ -4469,7 +4502,7 @@ var GeminiProvider = class {
     this.assertSafeInteractionOptions(options);
     const body = this.buildInteractionRequestBody(messages, options, true);
     const headers = this.buildHeaders(await this.resolveKey());
-    const recorder = new CallTimingRecorder();
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/interactions?alt=sse`,
       { method: "POST", headers, body: JSON.stringify(body), signal: options.signal },
@@ -6188,7 +6221,7 @@ var GEMINI_AUDIO_MEDIA_TYPES = /* @__PURE__ */ new Set([
   "audio/mulaw",
   "audio/webm"
 ]);
-function abortError2() {
+function abortError() {
   return new DOMException("The transcription operation was aborted", "AbortError");
 }
 function audioMime(audio) {
@@ -6220,13 +6253,13 @@ function secondsOffset(value) {
 function sleep3(ms, signal) {
   return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
-      reject(abortError2());
+      reject(abortError());
       return;
     }
     const timer = setTimeout(done, ms);
     const onAbort = () => {
       clearTimeout(timer);
-      done(abortError2());
+      done(abortError());
     };
     function done(error) {
       signal?.removeEventListener("abort", onAbort);
@@ -7547,7 +7580,7 @@ function isCostBearingLeaf(event) {
   return COST_LEAF_SET.has(event.type);
 }
 function isUnpricedLeaf(event) {
-  return event.type !== void 0 && COST_LEAF_SET.has(event.type) && !isUsableCost(event.cost) && hasPositiveBillableWork(event);
+  return event.type !== void 0 && COST_LEAF_SET.has(event.type) && !isUsableCost(event.cost) && (event.unpriced === true || hasPositiveBillableWork(event));
 }
 function isRootLevel(event) {
   const d = event.depth;
@@ -8833,18 +8866,27 @@ function parseDuration(duration) {
   if (!match) throw new Error(`Invalid duration format: "${duration}"`);
   const value = parseFloat(match[1]);
   const unit = match[2];
+  let milliseconds;
   switch (unit) {
     case "ms":
-      return value;
+      milliseconds = value;
+      break;
     case "s":
-      return value * 1e3;
+      milliseconds = value * 1e3;
+      break;
     case "m":
-      return value * 6e4;
+      milliseconds = value * 6e4;
+      break;
     case "h":
-      return value * 36e5;
+      milliseconds = value * 36e5;
+      break;
     default:
       throw new Error(`Unknown duration unit: "${unit}"`);
   }
+  if (!Number.isFinite(milliseconds)) {
+    throw new Error(`Duration is too large: "${duration}"`);
+  }
+  return milliseconds;
 }
 function parseCost(cost) {
   const match = cost.match(/^\$?([\d.]+)$/);
@@ -9500,6 +9542,42 @@ function recordToolSpanOutcome(span, outcome) {
 
 // src/context.ts
 var signalStorage = new AsyncLocalStorage();
+var hardSignalStorage = new AsyncLocalStorage();
+var timeoutTrackerStorage = new AsyncLocalStorage();
+var MAX_TIMER_DELAY_MS = 2147483647;
+function composeAbortSignals(...signals) {
+  const active = signals.filter((signal) => signal !== void 0);
+  if (active.length === 0) return void 0;
+  if (active.length === 1) return active[0];
+  return AbortSignal.any(active);
+}
+function raceWithAbortSignal(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    void promise.catch(() => {
+    });
+    return Promise.reject(signal.reason);
+  }
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const finish = (callback) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const onAbort = () => finish(() => reject(signal.reason));
+    signal.addEventListener("abort", onAbort, { once: true });
+    if (signal.aborted) onAbort();
+    promise.then(
+      (value) => finish(() => resolve2(value)),
+      (error) => finish(() => reject(error))
+    );
+  });
+}
+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;
@@ -10301,7 +10379,10 @@ var WorkflowContext = class _WorkflowContext {
         tool_call_id: parsed.callId
       });
     }
-    if (settlement.abortError !== void 0) throw settlement.abortError;
+    if (settlement.abortError !== void 0) {
+      signal?.throwIfAborted();
+      throw settlement.abortError;
+    }
   }
   // ── ctx.ask() ─────────────────────────────────────────────────────────
   async ask(agent2, prompt, options) {
@@ -10317,7 +10398,10 @@ var WorkflowContext = class _WorkflowContext {
     const promptText = inputText(normalizedInput);
     const inputDescriptor = describeModelInput(normalizedInput);
     const agentName = agent2._name;
-    return this._checkpoint(
+    const inheritedHardSignal = hardSignalStorage.getStore() ?? this.signal;
+    const hardAskSignal = composeAbortSignals(inheritedHardSignal, options?.signal);
+    const askSignal = composeAbortSignals(this.currentSignal, options?.signal);
+    const runAsk = () => this._checkpoint(
       this._autoCheckpointName("ask", agentName),
       async () => {
         const parentFrame = askStorage.getStore();
@@ -10472,8 +10556,25 @@ var WorkflowContext = class _WorkflowContext {
       },
       { agent: agentName }
     );
+    const runWithAskSignal = () => askSignal ? signalStorage.run(askSignal, runAsk) : runAsk();
+    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],
+      () => this.executeAgentCallImpl(
+        agent2,
+        input,
+        options,
+        handoffMessages,
+        usageCapture,
+        sessionHistory
+      )
+    );
+  }
+  async executeAgentCallImpl(agent2, input, options, handoffMessages, usageCapture, sessionHistory = normalizeSessionHistory(this.sessionHistory)) {
     if (this.budgetContext?.exceeded) {
       const { limit, totalCost: spent, policy } = this.budgetContext;
       if (policy === "warn") {
@@ -10713,8 +10814,18 @@ ${appendedSchemaText}`;
       }
     }
     const maxTurns = agent2._config.maxTurns ?? 25;
-    const timeoutMs = parseDuration(agent2._config.timeout ?? "60s");
+    const timeoutMs = parseDuration(
+      options?.timeout ?? agent2._config.timeout ?? this.config.defaults?.timeout ?? "60s"
+    );
+    const stallTimeout = options?.stallTimeout ?? agent2._config.stallTimeout ?? this.config.defaults?.stallTimeout;
+    const stallTimeoutMs = stallTimeout === void 0 ? void 0 : parseDuration(stallTimeout);
+    if (stallTimeoutMs !== void 0 && stallTimeoutMs > MAX_TIMER_DELAY_MS) {
+      throw new RangeError(
+        `stallTimeout exceeds the maximum supported timer duration of ${MAX_TIMER_DELAY_MS}ms`
+      );
+    }
     const startTime = Date.now();
+    const timeoutTracker = timeoutTrackerStorage.getStore()?.at(-1);
     const timingTotals = { turns: 0, queuedMs: 0, retryMs: 0, wireMs: 0 };
     const currentMessages = [...messages];
     let turns = 0;
@@ -10729,7 +10840,8 @@ ${appendedSchemaText}`;
     let lastStartMaxAttempts = 1;
     while (turns < maxTurns) {
       this.currentSignal?.throwIfAborted();
-      const elapsedMs = Date.now() - startTime;
+      const now = Date.now();
+      const elapsedMs = now - startTime - (timeoutTracker ? pausedHumanWaitMs(timeoutTracker, now) : 0);
       if (elapsedMs > timeoutMs) {
         throw new TimeoutError(
           "ctx.ask()",
@@ -10743,7 +10855,8 @@ ${appendedSchemaText}`;
               0,
               elapsedMs - timingTotals.queuedMs - timingTotals.retryMs - timingTotals.wireMs
             )
-          } : void 0
+          } : void 0,
+          agent2._name
         );
       }
       turns++;
@@ -10790,6 +10903,43 @@ ${appendedSchemaText}`;
         providerOptions,
         signal: this.currentSignal
       };
+      const requestSignal = chatOptions.signal;
+      const hardRequestSignal = hardSignalStorage.getStore() ?? this.signal;
+      const stallController = stallTimeoutMs === void 0 ? void 0 : new AbortController();
+      const stallReason = stallController === void 0 ? void 0 : new DOMException("Provider request stalled", "StallTimeout");
+      let stallTimer;
+      let providerCallActive = true;
+      let requestDispatched = false;
+      const clearStallTimer = () => {
+        if (stallTimer !== void 0) {
+          clearTimeout(stallTimer);
+          stallTimer = void 0;
+        }
+      };
+      const armStallTimer = () => {
+        if (!providerCallActive || !stallController || !stallReason || stallTimeoutMs === void 0)
+          return;
+        requestDispatched = true;
+        clearStallTimer();
+        if (stallController.signal.aborted) return;
+        stallTimer = setTimeout(() => stallController.abort(stallReason), stallTimeoutMs);
+      };
+      if (stallController) {
+        chatOptions.signal = composeAbortSignals(requestSignal, stallController.signal);
+        chatOptions.requestLifecycle = {
+          onDispatch: armStallTimer,
+          onRetry: clearStallTimer
+        };
+      }
+      const providerSettlementSignal = composeAbortSignals(
+        hardRequestSignal,
+        stallController?.signal
+      );
+      const throwIfRequestStalled = () => {
+        if (stallReason !== void 0 && providerSettlementSignal?.reason === stallReason) {
+          throw new StallTimeoutError("ctx.ask()", stallTimeoutMs, agent2._name);
+        }
+      };
       if (options?.schema && toolDefs.length === 0) {
         const nativeOut = options?.nativeStructuredOutput ?? agent2._config.nativeStructuredOutput ?? false;
         chatOptions.responseFormat = nativeOut ? {
@@ -10876,55 +11026,77 @@ ${appendedSchemaText}`;
               });
             }
           }) : void 0;
-          for await (const chunk of provider.stream(
+          if (stallController && provider.reportsRequestLifecycle !== true) armStallTimer();
+          const providerStream = provider.stream(
             cloneMessagesForProvider(currentMessages),
             chatOptions
-          )) {
-            if (chunk.type === "text_delta") {
-              content2 += chunk.content;
-              this.emitEvent({ type: "token", data: chunk.content });
-              if (walker) {
-                walker.processChunk(chunk.content);
-                if (walker.consumeBoundary()) {
-                  let parsed;
-                  try {
-                    parsed = parsePartialJson(extractJson(content2));
-                  } catch {
-                    parsed = void 0;
-                  }
-                  if (parsed !== void 0) {
-                    this.emitEvent({
-                      type: "partial_object",
-                      agent: agent2._name,
-                      attempt: currentAttempt,
-                      data: { object: parsed }
-                    });
+          );
+          const iterator = providerStream[Symbol.asyncIterator]();
+          try {
+            while (true) {
+              const next = await raceWithAbortSignal(
+                Promise.resolve(iterator.next()),
+                providerSettlementSignal
+              );
+              if (next.done) break;
+              const chunk = next.value;
+              if (stallController) armStallTimer();
+              if (chunk.type === "text_delta") {
+                content2 += chunk.content;
+                this.emitEvent({ type: "token", data: chunk.content });
+                if (walker) {
+                  walker.processChunk(chunk.content);
+                  if (walker.consumeBoundary()) {
+                    let parsed;
+                    try {
+                      parsed = parsePartialJson(extractJson(content2));
+                    } catch {
+                      parsed = void 0;
+                    }
+                    if (parsed !== void 0) {
+                      this.emitEvent({
+                        type: "partial_object",
+                        agent: agent2._name,
+                        attempt: currentAttempt,
+                        data: { object: parsed }
+                      });
+                    }
                   }
                 }
-              }
-            } else if (chunk.type === "thinking_delta") {
-              thinkingContent += chunk.content;
-            } else if (chunk.type === "tool_call_delta") {
-              let buffer = toolCallBuffers.get(chunk.id);
-              if (!buffer) {
-                buffer = { id: chunk.id, name: "", arguments: "" };
-                toolCallBuffers.set(chunk.id, buffer);
-              }
-              if (chunk.name) buffer.name = chunk.name;
-              if (chunk.arguments) buffer.arguments += chunk.arguments;
-            } else if (chunk.type === "done") {
-              streamProviderMetadata = chunk.providerMetadata;
-              streamTiming = chunk.timing;
-              if (chunk.usage) {
+              } else if (chunk.type === "thinking_delta") {
+                thinkingContent += chunk.content;
+              } else if (chunk.type === "tool_call_delta") {
+                let buffer = toolCallBuffers.get(chunk.id);
+                if (!buffer) {
+                  buffer = { id: chunk.id, name: "", arguments: "" };
+                  toolCallBuffers.set(chunk.id, buffer);
+                }
+                if (chunk.name) buffer.name = chunk.name;
+                if (chunk.arguments) buffer.arguments += chunk.arguments;
+              } else if (chunk.type === "done") {
+                streamProviderMetadata = chunk.providerMetadata;
+                streamTiming = chunk.timing;
                 response = {
                   content: content2,
                   tool_calls: void 0,
                   usage: chunk.usage,
-                  cost: chunk.cost
+                  cost: chunk.cost,
+                  providerMetadata: chunk.providerMetadata,
+                  timing: chunk.timing
                 };
               }
             }
+          } catch (error) {
+            if (iterator.return) {
+              try {
+                void Promise.resolve(iterator.return(void 0)).catch(() => {
+                });
+              } catch {
+              }
+            }
+            throw error;
           }
+          throwIfRequestStalled();
           for (const buffer of toolCallBuffers.values()) {
             toolCalls.push({
               id: buffer.id,
@@ -10949,16 +11121,27 @@ ${appendedSchemaText}`;
             response.thinking_content = thinkingContent;
           }
         } else {
-          response = await provider.chat(cloneMessagesForProvider(currentMessages), chatOptions);
+          if (stallController && provider.reportsRequestLifecycle !== true) armStallTimer();
+          response = await raceWithAbortSignal(
+            provider.chat(cloneMessagesForProvider(currentMessages), chatOptions),
+            providerSettlementSignal
+          );
+          throwIfRequestStalled();
         }
       } catch (err) {
-        if (richRequest) this.recordRichFailure(err);
-        const failureTiming = err instanceof ProviderError ? err.timing : void 0;
+        const callError = stallReason !== void 0 && providerSettlementSignal?.reason === stallReason ? new StallTimeoutError("ctx.ask()", stallTimeoutMs, agent2._name) : err;
+        if (richRequest) this.recordRichFailure(callError);
+        const failureTiming = callError instanceof ProviderError ? callError.timing : void 0;
         this.emitEvent({
           type: "agent_call_end",
           agent: agent2._name,
           model: effectiveModelUri,
           promptVersion: agent2._config.version,
+          // A dispatched request abandoned at the runtime boundary may still
+          // be billed even though a non-cooperative provider supplied no
+          // usage. Preserve budget honesty by marking the known total as a
+          // lower bound rather than presenting an exact $0.
+          ...callError instanceof StallTimeoutError && requestDispatched ? { unpriced: true } : {},
           duration: Date.now() - turnStart,
           // Top-level beside `duration`, exactly as on the success path.
           ...failureTiming ? { timing: failureTiming } : {},
@@ -10966,14 +11149,17 @@ ${appendedSchemaText}`;
             response: "",
             turn: turns,
             ...retryReason ? { retryReason } : {},
-            error: this._observerErrorProjection(err)?.message ?? legacyErrorMessage(err),
+            error: this._observerErrorProjection(callError)?.message ?? legacyErrorMessage(callError),
             // Enrich with typed-error metadata when available. `body` is
             // deliberately NOT emitted — it's redaction-eligible (see
             // docs/security.md). `data.error` already carries the message.
-            ...providerErrorEventMetadata(err, richRequest)
+            ...providerErrorEventMetadata(callError, richRequest)
           }
         });
-        throw err;
+        throw callError;
+      } finally {
+        providerCallActive = false;
+        clearStallTimer();
       }
       if (usageCapture && response.usage) {
         usageCapture.value = response.usage;
@@ -12498,46 +12684,52 @@ ${summaryResponse.content}`
   }
   // ── ctx.awaitHuman() ──────────────────────────────────────────────────
   async awaitHuman(options) {
-    if (this.spanManager) {
-      return this.spanManager.withSpanAsync(
-        "axl.ctx.awaitHuman",
-        {
-          "axl.awaitHuman.channel": options.channel
-        },
-        async (span) => {
-          const start = Date.now();
-          const result = await this._awaitHumanImpl(options);
-          span.setAttribute("axl.awaitHuman.wait_duration", Date.now() - start);
-          span.setAttribute("axl.awaitHuman.approved", result.approved);
-          return result;
+    const trackers = timeoutTrackerStorage.getStore();
+    const startedAt = Date.now();
+    for (const tracker of trackers ?? []) {
+      if (tracker.activeHumanWaits++ === 0) tracker.humanWaitStartedAt = startedAt;
+    }
+    try {
+      if (this.spanManager) {
+        return await this.spanManager.withSpanAsync(
+          "axl.ctx.awaitHuman",
+          {
+            "axl.awaitHuman.channel": options.channel
+          },
+          async (span) => {
+            const start = Date.now();
+            const result = await this._awaitHumanImpl(options);
+            span.setAttribute("axl.awaitHuman.wait_duration", Date.now() - start);
+            span.setAttribute("axl.awaitHuman.approved", result.approved);
+            return result;
+          }
+        );
+      }
+      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;
         }
-      );
+      }
     }
-    return this._awaitHumanImpl(options);
   }
   async _awaitHumanImpl(options) {
     const branchSignal = this.currentSignal;
-    const makeAbortError = (reason) => {
-      if (typeof DOMException !== "undefined") {
-        return new DOMException(
-          typeof reason === "string" ? reason : "awaitHuman aborted",
-          "AbortError"
-        );
-      }
-      const err = new Error(typeof reason === "string" ? reason : "awaitHuman aborted");
-      err.name = "AbortError";
-      return err;
-    };
     const awaitWithAbort = async (promise, signal2 = branchSignal) => {
       if (!signal2) return promise;
-      if (signal2.aborted) throw makeAbortError(signal2.reason);
+      signal2.throwIfAborted();
       let onAbort;
       try {
         return await Promise.race([
           promise,
           new Promise((_, reject) => {
-            onAbort = () => reject(makeAbortError(signal2.reason));
+            onAbort = () => reject(signal2.reason);
             signal2.addEventListener("abort", onAbort, { once: true });
+            if (signal2.aborted) onAbort();
           })
         ]);
       } finally {
@@ -12545,12 +12737,12 @@ ${summaryResponse.content}`
       }
     };
     if (this.awaitHumanHandler) {
-      if (branchSignal?.aborted) throw makeAbortError(branchSignal.reason);
+      branchSignal?.throwIfAborted();
       this.emitEvent({
         type: "await_human",
         data: { channel: options.channel, prompt: options.prompt }
       });
-      if (branchSignal?.aborted) throw makeAbortError(branchSignal.reason);
+      branchSignal?.throwIfAborted();
       const decision2 = parseHumanDecision(
         await awaitWithAbort(Promise.resolve(this.awaitHumanHandler(options)))
       );
@@ -12605,12 +12797,12 @@ ${summaryResponse.content}`
     const abortListener = () => {
       registeredResolver.cancelled = true;
       markReady();
-      rejectDecision(makeAbortError(signal.reason));
+      rejectDecision(signal.reason);
     };
     signal.addEventListener("abort", abortListener, { once: true });
     let decision;
     try {
-      if (signal.aborted) throw makeAbortError(signal.reason);
+      signal.throwIfAborted();
       if (this.stateStore) {
         saveAttempted = true;
         await this.stateStore.savePendingDecision(this.executionId, {
@@ -12621,7 +12813,7 @@ ${summaryResponse.content}`
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         });
       }
-      if (signal.aborted) throw makeAbortError(signal.reason);
+      signal.throwIfAborted();
       this.emitEvent({
         type: "await_human",
         data: { channel: options.channel, prompt: options.prompt }
@@ -13091,7 +13283,7 @@ ${summaryResponse.content}`
         data: partial.data
       });
     };
-    const abortError3 = () => new DOMException("The transcription operation was aborted", "AbortError");
+    const abortError2 = () => new DOMException("The transcription operation was aborted", "AbortError");
     const cleanupStatus = (value) => value === "not_required" || value === "deleted" || value === "failed" || value === "timed_out" ? value : void 0;
     const safeProviderFailure = (error, provider, model) => {
       const details = error && typeof error === "object" ? error : void 0;
@@ -13142,7 +13334,7 @@ ${summaryResponse.content}`
             hasWork: false
           })
         });
-        throw abortError3();
+        throw abortError2();
       }
       if (this.budgetContext?.exceeded) {
         const { limit, totalCost: spent, policy } = this.budgetContext;
@@ -13208,7 +13400,7 @@ ${summaryResponse.content}`
               ...failure.cleanup ? [{ cleanupStatus: failure.cleanup }] : []
             )
           });
-          throw abortError3();
+          throw abortError2();
         }
         if (failure.accounting.cost !== void 0)
           this._accumulateBudgetCost(failure.accounting.cost);
@@ -13251,7 +13443,7 @@ ${summaryResponse.content}`
             ...cleanupStatus(result.cleanupStatus) ? [{ cleanupStatus: cleanupStatus(result.cleanupStatus) }] : []
           )
         });
-        throw abortError3();
+        throw abortError2();
       }
       let transcript;
       try {
@@ -13337,9 +13529,9 @@ ${summaryResponse.content}`
     const cost = partial.cost;
     if (COST_BEARING_LEAF_TYPES.includes(partial.type)) {
       const usable = isUsableCost(cost);
-      const unpriced = !usable && hasPositiveBillableWork(
+      const unpriced = !usable && (partial.unpriced === true || hasPositiveBillableWork(
         partial
-      );
+      ));
       if (frame) {
         if (usable) frame.askCost.value += cost;
         else if (unpriced) frame.askUnpriced = true;
@@ -13350,7 +13542,7 @@ ${summaryResponse.content}`
         if (!this.budgetContext.unpricedWarned && Number.isFinite(this.budgetContext.limit)) {
           this.budgetContext.unpricedWarned = true;
           console.warn(
-            "Budget honesty: unpriced work detected \u2014 this budget's cost limit is a lower bound and is NOT enforced on unpriced models. See docs/observability.md#budget-honesty."
+            "Budget honesty: unknown-cost work detected \u2014 this budget's cost limit is a lower bound and is NOT enforced on unknown spend. See docs/observability.md#budget-honesty."
           );
         }
       }
@@ -15319,12 +15511,13 @@ function forwardAbortSignal(external, internal) {
   if (!external) return () => {
   };
   if (external.aborted) {
-    internal.abort();
+    internal.abort(external.reason);
     return () => {
     };
   }
-  const onAbort = () => internal.abort();
+  const onAbort = () => internal.abort(external.reason);
   external.addEventListener("abort", onAbort, { once: true });
+  if (external.aborted) onAbort();
   return () => external.removeEventListener("abort", onAbort);
 }
 var AxlRuntime = class extends EventEmitter2 {
@@ -17805,6 +17998,7 @@ export {
   SQLiteStore,
   Session,
   SqliteVectorStore,
+  StallTimeoutError,
   ThinkTagScanner,
   TimeoutError,
   ToolFailure,