@axlsdk/axl 0.22.3 → 0.23.1

package/dist/index.js

@@ -170,9 +170,22 @@ var NoConsensus = class extends AxlError {
   }
 };
 var TimeoutError = class extends AxlError {
-  constructor(operation, timeoutMs) {
-    super("TIMEOUT", `${operation} exceeded timeout of ${timeoutMs}ms`);
+  /** Latency attribution for the timed-out operation, when measurable. */
+  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)` : "") + (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) {
@@ -719,6 +732,7 @@ var ProviderError = class extends AxlError {
     this.retryAfterMs = args.retryAfterMs;
     this.requestId = args.requestId;
     this.body = args.body;
+    if (args.timing) this.timing = args.timing;
   }
 };
 function isRetryableStatus(status) {
@@ -770,7 +784,8 @@ function buildProviderError(args) {
     message: args.message,
     retryAfterMs: args.headers ? parseRetryAfter(args.headers) : void 0,
     requestId: args.headers ? extractRequestId(args.headers) : void 0,
-    body: args.body
+    body: args.body,
+    timing: args.timing
   });
 }
 
@@ -807,14 +822,33 @@ async function fetchWithRetry(input, init, opts) {
   const maxRetries = opts?.maxRetries ?? MAX_RETRIES;
   const governor = opts?.governor;
   const provider = opts?.provider ?? "unknown";
+  const observer = opts?.timing;
   let acquired = false;
+  let queuedMs = 0;
   if (governor) {
+    const acquireStart = Date.now();
     await governor.acquire(init?.signal ?? void 0);
     acquired = true;
-  }
+    queuedMs = Date.now() - acquireStart;
+  }
+  let firstDispatchedAt = 0;
+  let dispatchedAt = 0;
+  let headersAt = 0;
+  const reportComplete = (attempts) => {
+    observer?.onComplete?.({
+      queuedMs,
+      attempts,
+      retryMs: dispatchedAt - firstDispatchedAt,
+      dispatchedAt,
+      headersAt
+    });
+  };
   try {
     for (let attempt = 0; ; attempt++) {
       let res;
+      dispatchedAt = Date.now();
+      if (attempt === 0) firstDispatchedAt = dispatchedAt;
+      observer?.onDispatch?.(attempt + 1, dispatchedAt);
       try {
         res = await fetch(input, { ...init, redirect: "manual" });
       } catch (err) {
@@ -826,18 +860,23 @@ 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;
       }
+      headersAt = Date.now();
       governor?.observe(res);
       if (res.ok || !RETRYABLE_STATUS_CODES.has(res.status) || attempt >= maxRetries) {
+        reportComplete(attempt + 1);
         return res;
       }
       if (init?.signal?.aborted) {
+        reportComplete(attempt + 1);
         return res;
       }
       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 {
@@ -845,10 +884,110 @@ async function fetchWithRetry(input, init, opts) {
   }
 }
 
-// src/providers/rate-limiter.ts
-function abortError() {
-  return Object.assign(new Error("The operation was aborted"), { name: "AbortError" });
+// 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;
+    }
+  };
+  /**
+   * Await one body read, charging only the wait itself to `wireMs`. Time the
+   * consumer spends between reads is excluded because it elapses outside this
+   * call.
+   */
+  async read(reader) {
+    const start = Date.now();
+    try {
+      return await reader.read();
+    } finally {
+      this.readWaitMs += Date.now() - start;
+    }
+  }
+  /** Stamp the first content delta. Idempotent — only the first call counts. */
+  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.
+   *
+   * Also the right reading at an adapter's `!res.ok` throw site on BOTH
+   * transports: headers have arrived, no body will be streamed, so
+   * dispatch → now is the whole of what the provider cost us.
+   */
+  chatTiming() {
+    const t = this.fetchTiming;
+    if (!t) return void 0;
+    return {
+      queuedMs: t.queuedMs,
+      attempts: t.attempts,
+      retryMs: t.retryMs,
+      ttfbMs: Math.max(0, t.headersAt - t.dispatchedAt),
+      wireMs: Math.max(0, Date.now() - t.dispatchedAt)
+    };
+  }
+  /** Timing for a streamed call. Call when building the terminal `done` chunk. */
+  streamTiming() {
+    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,
+      ...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)
+    };
+  }
+};
+async function* withCallTiming(recorder, source) {
+  for await (const chunk of source) {
+    if (chunk.type === "text_delta" || chunk.type === "thinking_delta") {
+      recorder.markFirstToken();
+      yield chunk;
+    } else if (chunk.type === "done") {
+      const timing = recorder.streamTiming();
+      yield timing ? { ...chunk, timing } : chunk;
+    } else {
+      const yieldedAt = Date.now();
+      yield chunk;
+      recorder.recordPreFirstTokenConsumerPause(yieldedAt);
+    }
+  }
 }
+function withChatTiming(recorder, response) {
+  const timing = recorder.chatTiming();
+  return timing ? { ...response, timing } : response;
+}
+
+// src/providers/rate-limiter.ts
 var RateLimiter = class {
   maxConcurrent;
   minIntervalMs;
@@ -897,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) {
@@ -1201,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"] } } : {};
   }
@@ -1297,6 +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(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/chat/completions`,
       {
@@ -1305,7 +1446,7 @@ var OpenAICompatibleProvider = class {
         body: JSON.stringify(body),
         signal: options.signal
       },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -1314,15 +1455,20 @@ var OpenAICompatibleProvider = class {
         status: res.status,
         headers: res.headers,
         message: this.extractErrorMessage(errorBody, res.status),
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
     const json = await res.json();
-    return this.parseResponse(json, this.requestModel(body, options.model), body);
+    return withChatTiming(
+      recorder,
+      this.parseResponse(json, this.requestModel(body, options.model), body)
+    );
   }
   async *stream(messages, options) {
     const headers = this.buildHeaders(await this.resolveKey());
     const body = this.buildRequestBody(messages, options, true);
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/chat/completions`,
       {
@@ -1331,7 +1477,7 @@ var OpenAICompatibleProvider = class {
         body: JSON.stringify(body),
         signal: options.signal
       },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -1340,13 +1486,17 @@ var OpenAICompatibleProvider = class {
         status: res.status,
         headers: res.headers,
         message: this.extractErrorMessage(errorBody, res.status),
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
     if (!res.body) {
       throw new Error(`${this.profile.label ?? this.profile.name} stream response has no body`);
     }
-    yield* this.parseSSEStream(res.body, this.requestModel(body, options.model), body);
+    yield* withCallTiming(
+      recorder,
+      this.parseSSEStream(res.body, this.requestModel(body, options.model), body, recorder)
+    );
   }
   // ---------------------------------------------------------------------------
   // Request building
@@ -1573,7 +1723,21 @@ var OpenAICompatibleProvider = class {
   // ---------------------------------------------------------------------------
   // SSE streaming
   // ---------------------------------------------------------------------------
-  async *parseSSEStream(body, model, request) {
+  /**
+   * PRIVATE, and deliberately not an extension point. It was `protected`, but
+   * nothing in or out of this repo overrides it, and `protected` could not
+   * carry the guarantee it appeared to: TypeScript checks an override for
+   * assignability, and a function type with fewer parameters is assignable to
+   * one with more — so an override that simply dropped the recorder still
+   * compiled and then reported `wireMs === ttfbMs` for the whole subclass. Its
+   * type is not exported from the barrel either, so a subclass author could not
+   * name what they were required to accept.
+   *
+   * A provider with a different wire format implements `Provider` (see
+   * docs/providers.md); an OpenAI-compatible one adds a `ProviderProfile`.
+   * Neither needs to reach in here.
+   */
+  async *parseSSEStream(body, model, request, timing) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -1633,7 +1797,7 @@ var OpenAICompatibleProvider = class {
     };
     try {
       for (; ; ) {
-        const { done, value } = await reader.read();
+        const { done, value } = await timing.read(reader);
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -1665,7 +1829,8 @@ var OpenAICompatibleProvider = class {
               status: 0,
               retryable: false,
               message,
-              body: JSON.stringify(parsed.error)
+              body: JSON.stringify(parsed.error),
+              timing: timing.streamTiming()
             });
           }
           if (parsed.model !== void 0 || parsed.service_tier !== void 0 || parsed.serviceTier !== void 0) {
@@ -1737,7 +1902,8 @@ var OpenAICompatibleProvider = class {
         provider: this.name,
         status: 0,
         retryable: true,
-        message: `${this.profile.label ?? this.profile.name} stream ended before [DONE]`
+        message: `${this.profile.label ?? this.profile.name} stream ended before [DONE]`,
+        timing: timing.streamTiming()
       });
     } finally {
       reader.releaseLock();
@@ -1776,12 +1942,12 @@ var DIRECT_OPENAI_CATALOG = [
   {
     aliases: ["gpt-5.6", "gpt-5.6-sol"],
     snapshotBase: "gpt-5.6-sol",
-    short: { input: 5 / M, cachedInput: 0.5 / M, cacheWrite: 6.25 / M, output: 30 / M },
+    short: { input: 4 / M, cachedInput: 0.4 / M, cacheWrite: 5 / M, output: 20 / M },
     long: withLongContext({
-      input: 5 / M,
-      cachedInput: 0.5 / M,
-      cacheWrite: 6.25 / M,
-      output: 30 / M
+      input: 4 / M,
+      cachedInput: 0.4 / M,
+      cacheWrite: 5 / M,
+      output: 20 / M
     }),
     contextBoundary: LONG_CONTEXT_BOUNDARY
   },
@@ -2210,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"] } } : {};
   }
@@ -2296,6 +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(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/responses`,
       {
@@ -2304,7 +2472,7 @@ var OpenAIResponsesProvider = class {
         body: JSON.stringify(body),
         signal: options.signal
       },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -2314,11 +2482,15 @@ var OpenAIResponsesProvider = class {
         status: res.status,
         headers: res.headers,
         message,
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
     const json = await res.json();
-    return this.parseResponse(json, this.requestModel(body, options.model), body);
+    return withChatTiming(
+      recorder,
+      this.parseResponse(json, this.requestModel(body, options.model), body)
+    );
   }
   // ---------------------------------------------------------------------------
   // stream - SSE streaming
@@ -2326,6 +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(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/responses`,
       {
@@ -2334,7 +2507,7 @@ var OpenAIResponsesProvider = class {
         body: JSON.stringify(body),
         signal: options.signal
       },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -2344,13 +2517,17 @@ var OpenAIResponsesProvider = class {
         status: res.status,
         headers: res.headers,
         message,
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
     if (!res.body) {
       throw new Error("OpenAI Responses stream has no body");
     }
-    yield* this.parseSSEStream(res.body, this.requestModel(body, options.model), body);
+    yield* withCallTiming(
+      recorder,
+      this.parseSSEStream(res.body, this.requestModel(body, options.model), body, recorder)
+    );
   }
   // ---------------------------------------------------------------------------
   // Internal: build request body
@@ -2552,7 +2729,7 @@ var OpenAIResponsesProvider = class {
   // ---------------------------------------------------------------------------
   // Internal: parse SSE stream
   // ---------------------------------------------------------------------------
-  async *parseSSEStream(body, model, request) {
+  async *parseSSEStream(body, model, request, timing) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -2560,7 +2737,7 @@ var OpenAIResponsesProvider = class {
     let eventType = "";
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        const { done, value } = await timing.read(reader);
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -2580,7 +2757,14 @@ var OpenAIResponsesProvider = class {
             } catch {
               continue;
             }
-            const chunk = this.handleStreamEvent(eventType, data, model, callIdMap, request);
+            const chunk = this.handleStreamEvent(
+              eventType,
+              data,
+              model,
+              callIdMap,
+              request,
+              timing
+            );
             if (chunk) {
               yield chunk;
               if (chunk.type === "done") return;
@@ -2594,7 +2778,7 @@ var OpenAIResponsesProvider = class {
       reader.releaseLock();
     }
   }
-  handleStreamEvent(eventType, data, model, callIdMap, request) {
+  handleStreamEvent(eventType, data, model, callIdMap, request, timing) {
     switch (eventType) {
       case "response.output_text.delta":
         return { type: "text_delta", content: data.delta ?? "" };
@@ -2650,7 +2834,8 @@ var OpenAIResponsesProvider = class {
           provider: this.name,
           status: 0,
           retryable: false,
-          message: `OpenAI Responses API error: ${errorMsg}`
+          message: `OpenAI Responses API error: ${errorMsg}`,
+          timing: timing.streamTiming()
         });
       }
       default:
@@ -2718,6 +2903,12 @@ function hasAnthropicProviderFileImage(messages) {
   );
 }
 var CLAUDE_CAPABILITIES = {
+  "claude-fable-5-1": {
+    thinking: "adaptive-always-on",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true
+  },
   "claude-fable-5": {
     thinking: "adaptive-always-on",
     effortLevels: ["low", "medium", "high", "xhigh", "max"],
@@ -2808,10 +2999,18 @@ var PRE_INFERENCE_GEO_MODELS = /* @__PURE__ */ new Set([
 function resolveClaudeCapability(model) {
   return CLAUDE_CAPABILITIES[model] ?? (LEGACY_CLAUDE_MODELS.has(model) ? LEGACY_CLAUDE_CAPABILITY : void 0);
 }
+var DEFAULT_CACHE_READ_MULTIPLIER = 0.1;
 var ANTHROPIC_RATES = {
+  "claude-fable-5-1": { input: 1e-5, output: 5e-5, cacheReadMultiplier: 0.025 },
   "claude-fable-5": { input: 1e-5, output: 5e-5 },
+  // Limited availability (Glasswing). Priced from the public pricing table; no
+  // CLAUDE_CAPABILITIES entry, because their thinking semantics are not
+  // documented per-model and an unverified capability would send the wrong
+  // request shape. Unknown IDs pass through unmodified, which is the safe side.
+  "claude-mythos-5-1": { input: 1e-5, output: 5e-5, cacheReadMultiplier: 0.025 },
+  "claude-mythos-5": { input: 1e-5, output: 5e-5 },
   "claude-opus-5": { input: 5e-6, output: 25e-6 },
-  "claude-sonnet-5": { input: 3e-6, output: 15e-6, sonnet5Intro: true },
+  "claude-sonnet-5": { input: 2e-6, output: 1e-5 },
   "claude-opus-4-8": { input: 5e-6, output: 25e-6 },
   "claude-opus-4-7": { input: 5e-6, output: 25e-6 },
   "claude-opus-4-6": { input: 5e-6, output: 25e-6 },
@@ -2850,7 +3049,7 @@ function anthropicStreamErrorStatus(type) {
       return 0;
   }
 }
-function estimateAnthropicCost(model, usage, now = /* @__PURE__ */ new Date()) {
+function estimateAnthropicCost(model, usage) {
   if (!model || !isValidTokenCount(usage.inputTokens) || !isValidTokenCount(usage.outputTokens)) {
     return void 0;
   }
@@ -2869,8 +3068,9 @@ function estimateAnthropicCost(model, usage, now = /* @__PURE__ */ new Date()) {
   if (usage.aggregateCacheWriteTokens !== void 0 && (!isValidTokenCount(usage.aggregateCacheWriteTokens) || usage.aggregateCacheWriteTokens !== cacheWriteTotal)) {
     return void 0;
   }
-  const { input, output } = rate.sonnet5Intro && now < /* @__PURE__ */ new Date("2026-09-01T00:00:00Z") ? { input: 2e-6, output: 1e-5 } : rate;
-  return usage.inputTokens * input + cacheRead * input * 0.1 + cacheWrite5m * input * 1.25 + cacheWrite1h * input * 2 + usage.outputTokens * output;
+  const { input, output } = rate;
+  const cacheReadRate = input * (rate.cacheReadMultiplier ?? DEFAULT_CACHE_READ_MULTIPLIER);
+  return usage.inputTokens * input + cacheRead * cacheReadRate + cacheWrite5m * input * 1.25 + cacheWrite1h * input * 2 + usage.outputTokens * output;
 }
 var THINKING_BUDGETS = {
   low: 1024,
@@ -3102,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
@@ -3111,6 +3312,14 @@ var AnthropicProvider = class {
     const resolved = resolveThinkingOptions(options);
     if (resolved.effort === void 0 || resolved.hasBudgetOverride) return void 0;
     const model = typeof options.providerOptions?.model === "string" ? options.providerOptions.model : options.model;
+    if (ANTHROPIC_RATES[model] && !resolveClaudeCapability(model)) {
+      return {
+        requested: resolved.effort,
+        effective: "unset",
+        clamped: true,
+        cause: `Axl has no capability entry for Anthropic ${model}, so no reasoning control was sent and effort '${resolved.effort}' had no effect`
+      };
+    }
     const config = resolveClaudeThinking(model, resolved);
     const wireEffort = typeof config.outputConfig?.effort === "string" ? config.outputConfig.effort : void 0;
     const effective = config.clamp?.effective ?? wireEffort;
@@ -3166,6 +3375,10 @@ var AnthropicProvider = class {
   }
   /** Anthropic ignores native `json_schema` structurally — Axl uses a system
    *  prompt JSON instruction + client-side Zod validation (see buildRequest). */
+  /** The only built-in adapter that honors `promptCache` (see buildBody). */
+  realizesPromptCache() {
+    return true;
+  }
   nativeStructuredOutputSupport() {
     return "unsupported";
   }
@@ -3207,6 +3420,7 @@ var AnthropicProvider = class {
     );
     const body = this.buildRequestBody(messages, options, false);
     const pricingContext = pricingContextFromBody(body);
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/messages`,
       {
@@ -3215,7 +3429,7 @@ var AnthropicProvider = class {
         body: JSON.stringify(body),
         signal: options.signal
       },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -3225,11 +3439,12 @@ var AnthropicProvider = class {
         status: res.status,
         headers: res.headers,
         message,
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
     const json = await res.json();
-    return this.parseResponse(json, pricingContext);
+    return withChatTiming(recorder, this.parseResponse(json, pricingContext));
   }
   // ---------------------------------------------------------------------------
   // stream - SSE streaming completion
@@ -3241,6 +3456,7 @@ var AnthropicProvider = class {
     );
     const body = this.buildRequestBody(messages, options, true);
     const pricingContext = pricingContextFromBody(body);
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/messages`,
       {
@@ -3249,7 +3465,7 @@ var AnthropicProvider = class {
         body: JSON.stringify(body),
         signal: options.signal
       },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -3259,13 +3475,17 @@ var AnthropicProvider = class {
         status: res.status,
         headers: res.headers,
         message,
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
     if (!res.body) {
       throw new Error("Anthropic stream response has no body");
     }
-    yield* this.parseSSEStream(res.body, pricingContext, res.headers);
+    yield* withCallTiming(
+      recorder,
+      this.parseSSEStream(res.body, pricingContext, res.headers, recorder)
+    );
   }
   // ---------------------------------------------------------------------------
   // Internal: request building
@@ -3300,14 +3520,31 @@ var AnthropicProvider = class {
       max_tokens: options.maxTokens ?? 4096,
       stream
     };
-    if (systemText) {
+    const po = options.providerOptions;
+    const callerOwnsPrefix = po !== void 0 && (po.cache_control !== void 0 || po.system !== void 0 || po.tools !== void 0);
+    const promptCache = options.promptCache === true && !callerOwnsPrefix;
+    const anchorOnSystem = promptCache && systemMessages.length > 0 && systemMessages[0].origin !== "runtime";
+    if (anchorOnSystem) {
+      body.system = systemMessages.map((m, index) => ({
+        type: "text",
+        text: typeof m.content === "string" ? m.content : "",
+        ...index === 0 ? { cache_control: { type: "ephemeral" } } : {}
+      }));
+    } else if (systemText) {
       body.system = systemText;
     }
     if (options.stop) {
       body.stop_sequences = options.stop;
     }
     if (options.tools && options.tools.length > 0) {
-      body.tools = options.tools.map((t) => this.mapToolDefinition(t));
+      const tools = options.tools.map((t) => this.mapToolDefinition(t));
+      if (promptCache && !anchorOnSystem) {
+        tools[tools.length - 1] = {
+          ...tools[tools.length - 1],
+          cache_control: { type: "ephemeral" }
+        };
+      }
+      body.tools = tools;
     }
     if (options.toolChoice !== void 0) {
       body.tool_choice = this.mapToolChoice(options.toolChoice);
@@ -3326,9 +3563,13 @@ var AnthropicProvider = class {
     }
     if (options.responseFormat && options.responseFormat.type !== "text") {
       const jsonInstruction = "You must respond with valid JSON only. No markdown fences, no extra text.";
-      body.system = body.system ? `${body.system}
+      if (Array.isArray(body.system)) {
+        body.system = [...body.system, { type: "text", text: jsonInstruction }];
+      } else {
+        body.system = body.system ? `${body.system}
 
 ${jsonInstruction}` : jsonInstruction;
+      }
     }
     if (options.providerOptions) {
       Object.assign(body, options.providerOptions);
@@ -3508,7 +3749,7 @@ ${jsonInstruction}` : jsonInstruction;
   // ---------------------------------------------------------------------------
   // Internal: SSE stream parsing
   // ---------------------------------------------------------------------------
-  async *parseSSEStream(body, pricingContext, responseHeaders) {
+  async *parseSSEStream(body, pricingContext, responseHeaders, timing) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -3537,7 +3778,7 @@ ${jsonInstruction}` : jsonInstruction;
     });
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        const { done, value } = await timing.read(reader);
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -3560,7 +3801,8 @@ ${jsonInstruction}` : jsonInstruction;
                 provider: this.name,
                 status,
                 headers: responseHeaders,
-                message: event.error?.message ?? "Anthropic stream failed"
+                message: event.error?.message ?? "Anthropic stream failed",
+                timing: timing.streamTiming()
               });
             }
             case "content_block_start": {
@@ -3796,7 +4038,6 @@ var GEMINI_PRICING = {
   },
   "gemini-2.5-flash": { input: 3e-7, cached: 3e-8, output: 25e-7 },
   "gemini-2.5-flash-lite": { input: 1e-7, cached: 1e-8, output: 4e-7 },
-  "gemini-3-flash-preview": { input: 5e-7, cached: 5e-8, output: 3e-6 },
   "gemini-3.1-pro-preview": {
     input: 2e-6,
     cached: 2e-7,
@@ -3812,7 +4053,9 @@ var GEMINI_PRICING = {
   "gemini-3.1-flash-lite": { input: 25e-8, cached: 25e-9, output: 15e-7 },
   "gemini-3.5-flash": { input: 15e-7, cached: 15e-8, output: 9e-6 },
   "gemini-3.5-flash-lite": { input: 3e-7, cached: 3e-8, output: 25e-7 },
-  "gemini-3.6-flash": { input: 15e-7, cached: 15e-8, output: 75e-7 }
+  "gemini-3.6-flash": { input: 75e-8, cached: 75e-9, output: 375e-8 },
+  "gemini-3.7-flash": { input: 75e-8, cached: 75e-9, output: 375e-8 },
+  "gemini-3.8-flash": { input: 75e-8, cached: 75e-9, output: 375e-8 }
 };
 function isValidTokenCount2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
@@ -4040,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"] } } : {};
   }
@@ -4157,6 +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(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/models/${pricingContext.model}:generateContent`,
       {
@@ -4165,7 +4410,7 @@ var GeminiProvider = class {
         body: JSON.stringify(body),
         signal: options.signal
       },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -4175,11 +4420,12 @@ var GeminiProvider = class {
         status: res.status,
         headers: res.headers,
         message,
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
     const json = await res.json();
-    return this.parseResponse(json, pricingContext);
+    return withChatTiming(recorder, this.parseResponse(json, pricingContext));
   }
   // ---------------------------------------------------------------------------
   // stream - SSE streaming completion
@@ -4193,6 +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(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/models/${pricingContext.model}:streamGenerateContent?alt=sse`,
       {
@@ -4201,7 +4448,7 @@ var GeminiProvider = class {
         body: JSON.stringify(body),
         signal: options.signal
       },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -4211,13 +4458,14 @@ var GeminiProvider = class {
         status: res.status,
         headers: res.headers,
         message,
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
     if (!res.body) {
       throw new Error("Gemini stream response has no body");
     }
-    yield* this.parseSSEStream(res.body, pricingContext);
+    yield* withCallTiming(recorder, this.parseSSEStream(res.body, pricingContext, recorder));
   }
   // ---------------------------------------------------------------------------
   // Rich image requests use Gemini Interactions. It is deliberately stateless:
@@ -4228,10 +4476,11 @@ var GeminiProvider = class {
     this.assertSafeInteractionOptions(options);
     const body = this.buildInteractionRequestBody(messages, options, false);
     const headers = this.buildHeaders(await this.resolveKey());
+    const recorder = new CallTimingRecorder(options.requestLifecycle);
     const res = await fetchWithRetry(
       `${this.baseUrl}/interactions`,
       { method: "POST", headers, body: JSON.stringify(body), signal: options.signal },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -4240,19 +4489,24 @@ var GeminiProvider = class {
         status: res.status,
         headers: res.headers,
         message: this.extractErrorMessage(errorBody, res.status),
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
-    return this.parseInteractionResponse(await res.json());
+    return withChatTiming(
+      recorder,
+      this.parseInteractionResponse(await res.json())
+    );
   }
   async *streamInteraction(messages, options) {
     this.assertSafeInteractionOptions(options);
     const body = this.buildInteractionRequestBody(messages, options, true);
     const headers = this.buildHeaders(await this.resolveKey());
+    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 },
-      { governor: this.governor, provider: this.name }
+      { governor: this.governor, provider: this.name, timing: recorder.observer }
     );
     if (!res.ok) {
       const errorBody = await res.text();
@@ -4261,11 +4515,15 @@ var GeminiProvider = class {
         status: res.status,
         headers: res.headers,
         message: this.extractErrorMessage(errorBody, res.status),
-        body: errorBody
+        body: errorBody,
+        timing: recorder.chatTiming()
       });
     }
     if (!res.body) throw new Error("Gemini Interactions stream has no body");
-    yield* this.parseInteractionSSEStream(res.body, res.headers);
+    yield* withCallTiming(
+      recorder,
+      this.parseInteractionSSEStream(res.body, res.headers, recorder)
+    );
   }
   buildInteractionRequestBody(messages, options, stream) {
     const model = this.requestModel(options);
@@ -4421,7 +4679,7 @@ var GeminiProvider = class {
       providerMetadata: json.steps?.length ? { geminiInteractionSteps: json.steps.filter(isGeminiInteractionStep) } : void 0
     };
   }
-  async *parseInteractionSSEStream(body, responseHeaders) {
+  async *parseInteractionSSEStream(body, responseHeaders, timing) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -4431,7 +4689,7 @@ var GeminiProvider = class {
     let completed = false;
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        const { done, value } = await timing.read(reader);
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -4454,14 +4712,16 @@ var GeminiProvider = class {
                 provider: this.name,
                 status,
                 headers: responseHeaders,
-                message
+                message,
+                timing: timing.streamTiming()
               });
             }
             throw new ProviderError({
               provider: this.name,
               status: 0,
               retryable: false,
-              message
+              message,
+              timing: timing.streamTiming()
             });
           }
           if (event.event_type === "step.start" && event.step) {
@@ -4939,7 +5199,7 @@ var GeminiProvider = class {
   // ---------------------------------------------------------------------------
   // Internal: SSE stream parsing
   // ---------------------------------------------------------------------------
-  async *parseSSEStream(body, pricingContext) {
+  async *parseSSEStream(body, pricingContext, timing) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -4952,7 +5212,7 @@ var GeminiProvider = class {
     const accumulatedParts = [];
     try {
       while (true) {
-        const { done, value } = await reader.read();
+        const { done, value } = await timing.read(reader);
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -5961,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) {
@@ -5993,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);
@@ -7320,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;
@@ -8606,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.]+)$/);
@@ -9273,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;
@@ -9462,6 +9767,13 @@ function describeValue(value) {
   }
   return `a value of type ${typeof value}`;
 }
+var PROMPT_CACHE_COLD_WRITE_WARN_AFTER = 2;
+function nextUserTurn(history, from) {
+  for (let i = Math.max(0, from); i < history.length; i++) {
+    if (history[i].role === "user") return i;
+  }
+  return void 0;
+}
 function estimateMessagesTokens(messages) {
   let total = 0;
   let unmeasured = false;
@@ -9601,6 +9913,13 @@ var WorkflowContext = class _WorkflowContext {
   workflowLifecycleState;
   signal;
   summaryCache;
+  /** Consecutive provider calls with promptCache on that wrote to the cache
+   *  without reading from it (prefix changes per call), and consecutive calls
+   *  with no cache activity at all (prefix below the model's minimum, which
+   *  Anthropic silently ignores). Either reports once per context. */
+  promptCacheColdWrites = 0;
+  promptCacheInactive = 0;
+  promptCacheWarned = false;
   workflowName;
   mcpManager;
   spanManager;
@@ -10060,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) {
@@ -10076,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();
@@ -10133,6 +10458,17 @@ var WorkflowContext = class _WorkflowContext {
                 const costAfter2 = this.budgetContext?.totalCost ?? 0;
                 span.setAttribute("axl.agent.cost", costAfter2 - costBefore);
                 span.setAttribute("axl.agent.duration", Date.now() - askStart);
+                if (usageCapture.timing) {
+                  const t = usageCapture.timing;
+                  span.setAttribute("axl.agent.queued_ms", t.queuedMs);
+                  span.setAttribute("axl.agent.retry_ms", t.retryMs);
+                  span.setAttribute("axl.agent.attempts", t.attempts);
+                  span.setAttribute("axl.agent.ttfb_ms", t.ttfbMs);
+                  span.setAttribute("axl.agent.wire_ms", t.wireMs);
+                  if (t.firstTokenMs !== void 0) {
+                    span.setAttribute("axl.agent.first_token_ms", t.firstTokenMs);
+                  }
+                }
                 if (usageCapture.value) {
                   span.setAttribute(
                     "axl.agent.prompt_tokens",
@@ -10220,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") {
@@ -10340,6 +10693,14 @@ var WorkflowContext = class _WorkflowContext {
       const toolTokens = toolDefs.length > 0 ? estimateTokens(JSON.stringify(toolDefs)) : 0;
       const overhead = systemTokens + toolTokens + reserveTokens;
       const availableForHistory = maxContext - overhead;
+      if (availableForHistory <= 0) {
+        this.emitEvent({
+          type: "log",
+          data: {
+            warning: `Agent '${agent2._name}' maxContext (${maxContext}) is at or below its fixed overhead (${overhead} = system ${systemTokens} + tools ${toolTokens} + reserve ${reserveTokens}); no session history can fit, so every ask summarizes, retaining at most the most recent exchange and sometimes none of it verbatim. The current input is always sent. Raise maxContext or lower contextManagement.reserveTokens.`
+          }
+        });
+      }
       const historyEstimate = estimateMessagesTokens(sessionHistory);
       if (historyEstimate.unmeasured) {
         this.emitEvent({
@@ -10405,6 +10766,7 @@ ${appendedSchemaText}`;
       if (handoffContext.length > 0) {
         messages.push({
           role: "system",
+          origin: "runtime",
           content: "The following is the conversation history from the previous agent that handed off to you:"
         });
         for (const msg of handoffContext) {
@@ -10452,8 +10814,19 @@ ${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;
     let guardrailOutputRetries = 0;
@@ -10467,8 +10840,24 @@ ${appendedSchemaText}`;
     let lastStartMaxAttempts = 1;
     while (turns < maxTurns) {
       this.currentSignal?.throwIfAborted();
-      if (Date.now() - startTime > timeoutMs) {
-        throw new TimeoutError("ctx.ask()", timeoutMs);
+      const now = Date.now();
+      const elapsedMs = now - startTime - (timeoutTracker ? pausedHumanWaitMs(timeoutTracker, now) : 0);
+      if (elapsedMs > timeoutMs) {
+        throw new TimeoutError(
+          "ctx.ask()",
+          timeoutMs,
+          timingTotals.turns > 0 ? {
+            elapsedMs,
+            queuedMs: timingTotals.queuedMs,
+            retryMs: timingTotals.retryMs,
+            wireMs: timingTotals.wireMs,
+            otherMs: Math.max(
+              0,
+              elapsedMs - timingTotals.queuedMs - timingTotals.retryMs - timingTotals.wireMs
+            )
+          } : void 0,
+          agent2._name
+        );
       }
       turns++;
       const isFirstTurn = turns === 1;
@@ -10508,11 +10897,49 @@ ${appendedSchemaText}`;
         effort: options?.effort ?? agent2._config.effort,
         thinkingBudget: options?.thinkingBudget ?? agent2._config.thinkingBudget,
         includeThoughts: options?.includeThoughts ?? agent2._config.includeThoughts,
+        promptCache: options?.promptCache ?? agent2._config.promptCache,
         toolChoice: options?.toolChoice ?? agent2._config.toolChoice,
         stop: options?.stop ?? agent2._config.stop,
         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 ? {
@@ -10585,6 +11012,7 @@ ${appendedSchemaText}`;
           const toolCalls = [];
           const toolCallBuffers = /* @__PURE__ */ new Map();
           let streamProviderMetadata;
+          let streamTiming;
           let thinkingContent = "";
           const streamingObjectEnabled = !!options?.schema && toolDefs.length === 0 && options.schema instanceof z.ZodObject;
           const currentAttempt = schemaRetries + 1;
@@ -10598,54 +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;
-              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,
@@ -10663,39 +11114,91 @@ ${appendedSchemaText}`;
           if (streamProviderMetadata) {
             response.providerMetadata = streamProviderMetadata;
           }
+          if (streamTiming) {
+            response.timing = streamTiming;
+          }
           if (thinkingContent) {
             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 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 } : {},
           data: {
             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;
       }
+      if (usageCapture && response.timing) {
+        usageCapture.timing = response.timing;
+      }
+      if (chatOptions.promptCache && provider.realizesPromptCache?.(model) === true && response.usage && !this.promptCacheWarned) {
+        const wrote = (response.usage.cache_write_tokens ?? 0) > 0;
+        const read = (response.usage.cached_tokens ?? 0) > 0;
+        if (read) {
+          this.promptCacheColdWrites = 0;
+          this.promptCacheInactive = 0;
+        } else if (wrote) {
+          this.promptCacheColdWrites += 1;
+          this.promptCacheInactive = 0;
+        } else {
+          this.promptCacheInactive += 1;
+        }
+        let warning;
+        if (this.promptCacheColdWrites >= PROMPT_CACHE_COLD_WRITE_WARN_AFTER) {
+          warning = `Agent '${agent2._name}' has promptCache on, but its prefix was written to the cache ${this.promptCacheColdWrites} times in a row with no cache reads. Each write bills 1.25x input. If this agent's system prompt or tool set changes per call, set promptCache: false for it.`;
+        } else if (this.promptCacheInactive >= PROMPT_CACHE_COLD_WRITE_WARN_AFTER) {
+          warning = `Agent '${agent2._name}' has promptCache on, but ${this.promptCacheInactive} calls in a row showed no cache writes or reads. Anthropic silently ignores a breakpoint below the model's minimum cacheable length (4,096 tokens on Haiku 4.5; 1,024 or 512 on others) -- the system prompt plus tools may be too short to cache on this model, or the provider may not support prompt caching.`;
+        }
+        if (warning) {
+          this.promptCacheWarned = true;
+          this.emitEvent({ type: "log", agent: agent2._name, data: { warning } });
+        }
+      }
       if (response.cost) {
         this._accumulateBudgetCost(response.cost);
       }
+      if (response.timing) {
+        timingTotals.turns += 1;
+        timingTotals.queuedMs += response.timing.queuedMs;
+        timingTotals.retryMs += response.timing.retryMs;
+        timingTotals.wireMs += response.timing.wireMs;
+      }
       this.emitEvent({
         type: "agent_call_end",
         agent: agent2._name,
@@ -10710,6 +11213,8 @@ ${appendedSchemaText}`;
           cacheWrite: response.usage.cache_write_tokens
         } : void 0,
         duration: Date.now() - turnStart,
+        // Additive beside `duration`, which keeps its turn-wall-clock meaning.
+        ...response.timing ? { timing: response.timing } : {},
         data: {
           response: response.content,
           ...response.thinking_content ? { thinking: response.thinking_content } : {},
@@ -11428,6 +11933,7 @@ ${appendedSchemaText}`;
     if (this.summaryCache) {
       const summaryMsg2 = {
         role: "system",
+        origin: "runtime",
         content: `Summary of earlier conversation:
 ${this.summaryCache}`
       };
@@ -11441,6 +11947,7 @@ ${this.summaryCache}`
         recentTokens2 += msgTokens;
         splitIdx2 = i;
       }
+      splitIdx2 = nextUserTurn(history, splitIdx2) ?? history.length;
       if (splitIdx2 < history.length) {
         return [summaryMsg2, ...history.slice(splitIdx2)];
       }
@@ -11454,6 +11961,19 @@ ${this.summaryCache}`
       recentTokens += msgTokens;
       splitIdx = i;
     }
+    const anchored = nextUserTurn(history, splitIdx);
+    if (anchored !== void 0) {
+      splitIdx = anchored;
+    } else if (splitIdx === history.length && history.length > 1) {
+      for (let i = history.length - 1; i > 0; i--) {
+        if (history[i].role === "user") {
+          splitIdx = i;
+          break;
+        }
+      }
+    } else {
+      splitIdx = history.length;
+    }
     if (splitIdx === 0) return history;
     const oldMessages = history.slice(0, splitIdx);
     const summaryModelUri = this.config.contextManagement?.summaryModel;
@@ -11485,6 +12005,7 @@ ${this.summaryCache}`
     }
     const summaryMsg = {
       role: "system",
+      origin: "runtime",
       content: `Summary of earlier conversation:
 ${summaryResponse.content}`
     };
@@ -12163,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 {
@@ -12210,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)))
       );
@@ -12270,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, {
@@ -12286,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 }
@@ -12756,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;
@@ -12807,7 +13334,7 @@ ${summaryResponse.content}`
             hasWork: false
           })
         });
-        throw abortError3();
+        throw abortError2();
       }
       if (this.budgetContext?.exceeded) {
         const { limit, totalCost: spent, policy } = this.budgetContext;
@@ -12873,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);
@@ -12916,7 +13443,7 @@ ${summaryResponse.content}`
             ...cleanupStatus(result.cleanupStatus) ? [{ cleanupStatus: cleanupStatus(result.cleanupStatus) }] : []
           )
         });
-        throw abortError3();
+        throw abortError2();
       }
       let transcript;
       try {
@@ -13002,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;
@@ -13015,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."
           );
         }
       }
@@ -14984,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 {
@@ -16260,6 +16788,8 @@ var AxlRuntime = class extends EventEmitter2 {
       parent: parentScope
     };
     const modelCalls = /* @__PURE__ */ new Map();
+    const modelTiming = /* @__PURE__ */ new Map();
+    const captureTimingSamples = options?.captureTimingSamples === true;
     const workflowCalls = /* @__PURE__ */ new Map();
     const tokens = { input: 0, output: 0, reasoning: 0 };
     let agentCalls = 0;
@@ -16277,6 +16807,30 @@ var AxlRuntime = class extends EventEmitter2 {
           tokens.output += event.tokens.output ?? 0;
           tokens.reasoning += event.tokens.reasoning ?? 0;
         }
+        const failed2 = event.data?.error != null;
+        if (event.model && event.timing && !failed2) {
+          const t = event.timing;
+          let bucket = modelTiming.get(event.model);
+          if (!bucket) {
+            bucket = {
+              calls: 0,
+              queuedMs: 0,
+              retryMs: 0,
+              wireMs: 0,
+              ...captureTimingSamples ? { samples: [] } : {}
+            };
+            modelTiming.set(event.model, bucket);
+          }
+          bucket.calls++;
+          bucket.samples?.push(t);
+          bucket.queuedMs += t.queuedMs;
+          bucket.retryMs += t.retryMs;
+          bucket.wireMs += t.wireMs;
+          if (t.firstTokenMs != null) {
+            bucket.firstTokenMs = (bucket.firstTokenMs ?? 0) + t.firstTokenMs;
+            bucket.firstTokenCalls = (bucket.firstTokenCalls ?? 0) + 1;
+          }
+        }
       }
       if (event.type === "workflow_start" && event.workflow) {
         workflowCalls.set(event.workflow, (workflowCalls.get(event.workflow) ?? 0) + 1);
@@ -16307,6 +16861,7 @@ var AxlRuntime = class extends EventEmitter2 {
         result,
         cost: scope.totalCost,
         unpriced,
+        ...modelTiming.size > 0 ? { modelTiming: Object.fromEntries(modelTiming) } : {},
         ...capturedTraces ? { traces: capturedTraces } : {},
         metadata: {
           models: [...modelCalls.keys()],
@@ -17443,6 +17998,7 @@ export {
   SQLiteStore,
   Session,
   SqliteVectorStore,
+  StallTimeoutError,
   ThinkTagScanner,
   TimeoutError,
   ToolFailure,