@axlsdk/axl 0.24.3 → 0.25.1

package/dist/index.js

@@ -40,6 +40,23 @@ var UnsupportedModelInputError = class extends AxlError {
     this.source = options.source;
   }
 };
+var UnsupportedModelOptionError = class extends AxlError {
+  provider;
+  model;
+  option;
+  remediation;
+  constructor(options) {
+    super(
+      "UNSUPPORTED_MODEL_OPTION",
+      `Provider '${options.provider}' model '${options.model}' does not support ${options.option}. ${options.remediation}`
+    );
+    this.name = "UnsupportedModelOptionError";
+    this.provider = options.provider;
+    this.model = options.model;
+    this.option = options.option;
+    this.remediation = options.remediation;
+  }
+};
 var InvalidTranscriptionInputError = class extends AxlError {
   constructor(message) {
     super("INVALID_TRANSCRIPTION_INPUT", message);
@@ -193,7 +210,7 @@ var TimeoutError = class extends AxlError {
   constructor(operation, timeoutMs, breakdown, agent2) {
     super(
       "TIMEOUT",
-      `${operation} exceeded timeout of ${timeoutMs}ms` + (breakdown ? ` (elapsed ${breakdown.elapsedMs}ms: queued ${breakdown.queuedMs}ms, retries ${breakdown.retryMs}ms, wire ${breakdown.wireMs}ms, other ${breakdown.otherMs}ms)` : "") + (agent2 ? ` for agent '${agent2}'` : "")
+      `${operation} exceeded timeout of ${timeoutMs}ms` + (breakdown ? ` (elapsed ${breakdown.elapsedMs}ms: queued ${breakdown.queuedMs}ms, retries ${breakdown.retryMs}ms, wire ${breakdown.wireMs}ms, other ${breakdown.otherMs}ms, charged ${breakdown.chargedMs}ms)` : "") + (agent2 ? ` for agent '${agent2}'` : "")
     );
     this.name = "TimeoutError";
     if (breakdown) this.breakdown = breakdown;
@@ -331,7 +348,7 @@ var sharedGuard = typeof installedGuard === "object" && installedGuard !== null
 var buildPath = typeof __AXL_BUILD_PATH__ === "string" ? __AXL_BUILD_PATH__ : "<source>";
 var thisCopy = {
   path: buildPath.startsWith("file:") ? fileURLToPath(buildPath) : buildPath,
-  version: true ? "0.24.3" : "unknown"
+  version: true ? "0.25.1" : "unknown"
 };
 function warnCrossCopy(other, joined) {
   if (other === thisCopy) return;
@@ -1315,6 +1332,41 @@ var OPENAI_DEFAULT_BASE_URL = "https://api.openai.com/v1";
 var ANTHROPIC_DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 var GEMINI_DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 
+// src/ask-clock.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var askClockStorage = new AsyncLocalStorage2();
+function runWithAskClock(fn) {
+  const tracker = { pausedMs: 0, activePauses: 0 };
+  const enclosing = askClockStorage.getStore() ?? [];
+  return askClockStorage.run([...enclosing, tracker], fn);
+}
+function currentAskClock() {
+  return askClockStorage.getStore()?.at(-1);
+}
+function pausedAskClockMs(tracker, now = Date.now()) {
+  return tracker.pausedMs + (tracker.activePauses > 0 && tracker.pauseStartedAt !== void 0 ? now - tracker.pauseStartedAt : 0);
+}
+async function pauseAskClocks(wait) {
+  const trackers = askClockStorage.getStore();
+  if (!trackers || trackers.length === 0) return wait();
+  const startedAt = Date.now();
+  for (const tracker of trackers) {
+    if (tracker.activePauses++ === 0) tracker.pauseStartedAt = startedAt;
+  }
+  try {
+    return await wait();
+  } finally {
+    const finishedAt = Date.now();
+    for (const tracker of trackers) {
+      tracker.activePauses--;
+      if (tracker.activePauses === 0 && tracker.pauseStartedAt !== void 0) {
+        tracker.pausedMs += finishedAt - tracker.pauseStartedAt;
+        tracker.pauseStartedAt = void 0;
+      }
+    }
+  }
+}
+
 // src/providers/rate-limiter.ts
 function sanitizeRateLimitConfig(config) {
   const limits = {};
@@ -2377,7 +2429,7 @@ async function fetchWithRetry(input, init, opts) {
   let headersAt = 0;
   const waitSelfImposed = async (wait) => {
     const start = Date.now();
-    await wait();
+    await pauseAskClocks(wait);
     const waited = Date.now() - start;
     queuedMs += waited;
     if (dispatches > 0) queuedAfterFirstDispatchMs += waited;
@@ -3169,8 +3221,12 @@ var OpenAICompatibleProvider = class {
     for (const key of forbidden) {
       if (!userKeys.includes(key)) delete body[key];
     }
+    this.validateFinalRequestBody(body);
     return body;
   }
+  /** Native subclasses may reject model-invalid fields after providerOptions merge. */
+  validateFinalRequestBody(_body) {
+  }
   formatMessage(msg, model) {
     const modalities = this.inputModalities(model);
     const out = {
@@ -3578,6 +3634,24 @@ var withLongContext = (short) => ({
   output: short.output * 1.5
 });
 var DIRECT_OPENAI_CATALOG = [
+  {
+    aliases: ["gpt-6-astra"],
+    short: { input: 10 / M, cachedInput: 1 / M, cacheWrite: 12.5 / M, output: 50 / M },
+    long: { input: 20 / M, cachedInput: 2 / M, cacheWrite: 25 / M, output: 75 / M },
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
+  {
+    aliases: ["gpt-6-sol"],
+    short: { input: 2 / M, cachedInput: 0.2 / M, cacheWrite: 2.5 / M, output: 10 / M },
+    long: { input: 4 / M, cachedInput: 0.4 / M, cacheWrite: 5 / M, output: 15 / M },
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
+  {
+    aliases: ["gpt-6-luna"],
+    short: { input: 0.1 / M, cachedInput: 0.01 / M, cacheWrite: 0.125 / M, output: 0.5 / M },
+    long: { input: 0.2 / M, cachedInput: 0.02 / M, cacheWrite: 0.25 / M, output: 0.75 / M },
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
   {
     aliases: ["gpt-5.6", "gpt-5.6-sol"],
     snapshotBase: "gpt-5.6-sol",
@@ -3908,7 +3982,7 @@ function estimateDirectOpenAICost(model, usage, context) {
   const audioOutput = audio_output_tokens ?? 0;
   if (![prompt_tokens, completion_tokens, cached, cacheWrite, audioInput, audioOutput].every(
     (count) => Number.isSafeInteger(count) && count >= 0
-  ) || cached + cacheWrite + audioInput > prompt_tokens || audioOutput > completion_tokens) {
+  ) || resolveOpenAIModelDescriptor(model).strictUsageTotals && (!Number.isSafeInteger(usage.total_tokens) || usage.total_tokens !== prompt_tokens + completion_tokens) || cached + cacheWrite + audioInput > prompt_tokens || audioOutput > completion_tokens) {
     return void 0;
   }
   if (audioInput > 0 && entry.audio === void 0 || audioOutput > 0 && entry.audio?.output === void 0) {
@@ -3933,57 +4007,206 @@ function estimateOpenAICost(model, promptTokens, completionTokens, cachedTokens)
     cached_tokens: cachedTokens
   });
 }
-function isOSeriesModel(model) {
-  return /^(o1|o3|o4-mini)/.test(model);
+var EFFORT_FALLBACK = {
+  none: "minimal",
+  minimal: "low",
+  low: "medium",
+  medium: "high",
+  max: "xhigh",
+  xhigh: "high"
+};
+var BASE_EFFORTS = ["minimal", "low", "medium", "high"];
+function bothEndpoints(value) {
+  return { chat: value, responses: value };
 }
-function supportsReasoningEffort(model) {
-  return isOSeriesModel(model) || /^gpt-5/.test(model);
+function gpt6(id, efforts, chatTools) {
+  return {
+    id,
+    family: "gpt-6",
+    reasoning: true,
+    efforts: bothEndpoints(efforts),
+    defaultEffort: "medium",
+    // Same policy as GPT-5.x: a portable `temperature` is dropped while
+    // reasoning is active (including the active default). A raw
+    // `providerOptions` sampling field is rejected by the final-body check.
+    sampling: bothEndpoints("unless-effort-none"),
+    chatTools,
+    validatesFinalBody: true,
+    strictUsageTotals: true
+  };
 }
-var GPT_56_REASONING_MODELS = /* @__PURE__ */ new Set([
-  "gpt-5.6",
-  "gpt-5.6-sol",
-  "gpt-5.6-terra",
-  "gpt-5.6-luna"
-]);
-function supportsMaxReasoningEffort(model) {
-  return GPT_56_REASONING_MODELS.has(model);
+function gpt56(id) {
+  const chat = ["none", ...BASE_EFFORTS, "xhigh"];
+  return {
+    id,
+    family: "gpt-5.6",
+    reasoning: true,
+    efforts: { chat, responses: [...chat, "max"] },
+    // Responses rejects temperature even at the provider-default effort.
+    sampling: { chat: "when-effort-sent", responses: "always" },
+    chatTools: "allowed",
+    validatesFinalBody: false,
+    strictUsageTotals: false
+  };
 }
-function supportsReasoningNone(model) {
-  return /^gpt-5\.[1-9]/.test(model);
+var OPENAI_EXACT_MODELS = new Map(
+  [
+    gpt6("gpt-6-astra", ["low", "medium", "high", "xhigh", "max"], "never"),
+    gpt6("gpt-6-sol", ["none", "low", "medium", "high", "xhigh", "max"], "effort-none-only"),
+    gpt6("gpt-6-luna", ["none", "low", "medium", "high", "xhigh", "max"], "effort-none-only"),
+    gpt56("gpt-5.6"),
+    gpt56("gpt-5.6-sol"),
+    gpt56("gpt-5.6-terra"),
+    gpt56("gpt-5.6-luna")
+  ].map((descriptor) => [descriptor.id, descriptor])
+);
+var O_SERIES_DESCRIPTOR = {
+  id: "o-series",
+  family: "o-series",
+  reasoning: true,
+  efforts: bothEndpoints(BASE_EFFORTS),
+  defaultEffort: "medium",
+  sampling: bothEndpoints("always"),
+  chatTools: "allowed",
+  validatesFinalBody: false,
+  strictUsageTotals: false
+};
+var GPT_5_PRO_DESCRIPTOR = {
+  id: "gpt-5-pro",
+  family: "gpt-5-pro",
+  reasoning: true,
+  efforts: bothEndpoints(["high"]),
+  defaultEffort: "high",
+  sampling: bothEndpoints("when-effort-sent"),
+  chatTools: "allowed",
+  validatesFinalBody: false,
+  strictUsageTotals: false
+};
+var DEFAULT_DESCRIPTOR = {
+  id: "default",
+  family: "default",
+  reasoning: false,
+  // Never emitted (the model is not reasoning-capable); keeps the clamp total.
+  efforts: bothEndpoints(BASE_EFFORTS),
+  sampling: bothEndpoints("never"),
+  chatTools: "allowed",
+  validatesFinalBody: false,
+  strictUsageTotals: false
+};
+function gpt5FamilyDescriptor(model) {
+  const none = /^gpt-5\.[1-9]/.test(model);
+  const xhigh = /^gpt-5\.([2-9]|\d{2,})/.test(model);
+  const efforts = [
+    ...none ? ["none"] : [],
+    ...BASE_EFFORTS,
+    ...xhigh ? ["xhigh"] : []
+  ];
+  return {
+    id: "gpt-5",
+    family: "gpt-5",
+    reasoning: true,
+    efforts: bothEndpoints(efforts),
+    ...none ? {} : { defaultEffort: "medium" },
+    sampling: bothEndpoints("when-effort-sent"),
+    chatTools: "allowed",
+    validatesFinalBody: false,
+    strictUsageTotals: false
+  };
 }
-function supportsXhigh(model) {
-  return /^gpt-5\.([2-9]|\d{2,})/.test(model);
+var OPENAI_FAMILY_FALLBACKS = [
+  { match: /^(o1|o3|o4-mini)/, describe: () => O_SERIES_DESCRIPTOR },
+  { match: /^gpt-5-pro/, describe: () => GPT_5_PRO_DESCRIPTOR },
+  { match: /^gpt-5/, describe: gpt5FamilyDescriptor }
+];
+function resolveOpenAIModelDescriptor(model) {
+  const exact = OPENAI_EXACT_MODELS.get(model);
+  if (exact) return exact;
+  const family = OPENAI_FAMILY_FALLBACKS.find((entry) => entry.match.test(model));
+  return family ? family.describe(model) : DEFAULT_DESCRIPTOR;
+}
+function clampToDescriptor(descriptor, endpoint, effort) {
+  const accepted = descriptor.efforts[endpoint];
+  let candidate = effort;
+  while (candidate !== void 0 && !accepted.includes(candidate)) {
+    candidate = EFFORT_FALLBACK[candidate];
+  }
+  if (candidate === void 0) {
+    throw new Error(
+      `OpenAI descriptor '${descriptor.id}' accepts no ${endpoint} effort reachable from '${effort}'`
+    );
+  }
+  return candidate;
 }
-function clampReasoningEffort(model, effort) {
-  if (model.startsWith("gpt-5-pro")) return "high";
-  if (effort === "none" && !supportsReasoningNone(model)) return "minimal";
-  if (effort === "max" && !supportsMaxReasoningEffort(model)) {
-    return clampReasoningEffort(model, "xhigh");
+function stripsPortableSampling(descriptor, endpoint, wireEffort) {
+  switch (descriptor.sampling[endpoint]) {
+    case "never":
+      return false;
+    case "always":
+      return true;
+    case "when-effort-sent":
+      return wireEffort !== void 0;
+    case "unless-effort-none":
+      return (wireEffort ?? descriptor.defaultEffort) !== "none";
   }
-  if (effort === "xhigh" && !supportsXhigh(model)) return "high";
-  return effort;
 }
-function effortToReasoningEffort(effort, model) {
-  return effort === "max" && model !== void 0 && supportsMaxReasoningEffort(model) ? "max" : effort === "max" ? "xhigh" : effort;
+function isOSeriesModel(model) {
+  return resolveOpenAIModelDescriptor(model).family === "o-series";
 }
 function budgetToReasoningEffort(budget) {
   if (budget <= 1024) return "low";
   if (budget <= 8192) return "medium";
   return "high";
 }
+function resolveEndpointReasoningEffort(model, endpoint, resolved) {
+  const descriptor = resolveOpenAIModelDescriptor(model);
+  if (!descriptor.reasoning) return void 0;
+  const requested = resolved.hasBudgetOverride ? budgetToReasoningEffort(resolved.thinkingBudget) : !resolved.thinkingDisabled && resolved.activeEffort ? resolved.activeEffort : resolved.thinkingDisabled ? "none" : void 0;
+  return requested === void 0 ? void 0 : clampToDescriptor(descriptor, endpoint, requested);
+}
 function resolveOpenAIReasoningEffort(model, resolved) {
-  if (!supportsReasoningEffort(model)) return void 0;
-  if (resolved.hasBudgetOverride) {
-    return clampReasoningEffort(model, budgetToReasoningEffort(resolved.thinkingBudget));
-  }
-  if (!resolved.thinkingDisabled && resolved.activeEffort) {
-    return clampReasoningEffort(model, effortToReasoningEffort(resolved.activeEffort, model));
-  }
-  return resolved.thinkingDisabled ? clampReasoningEffort(model, "none") : void 0;
+  return resolveEndpointReasoningEffort(model, "responses", resolved);
 }
 function resolveOpenAIChatReasoningEffort(model, resolved) {
-  const effort = resolveOpenAIReasoningEffort(model, resolved);
-  return effort === "max" ? "xhigh" : effort;
+  return resolveEndpointReasoningEffort(model, "chat", resolved);
+}
+function validateOpenAIFinalRequestBody(body, endpoint) {
+  const model = body.model;
+  if (typeof model !== "string") return;
+  const descriptor = resolveOpenAIModelDescriptor(model);
+  if (!descriptor.validatesFinalBody) return;
+  const provider = endpoint === "chat" ? "openai" : "openai-responses";
+  const fail = (option, remediation) => {
+    throw new UnsupportedModelOptionError({ provider, model, option, remediation });
+  };
+  const rawEffort = endpoint === "chat" ? body.reasoning_effort : body.reasoning !== null && typeof body.reasoning === "object" ? body.reasoning.effort : void 0;
+  const accepted = descriptor.efforts[endpoint];
+  if (rawEffort !== void 0 && !accepted.includes(rawEffort)) {
+    fail("reasoning effort", `Use one of: ${accepted.join(", ")}.`);
+  }
+  const activeReasoning = (rawEffort ?? descriptor.defaultEffort) !== "none";
+  if (endpoint === "chat" && descriptor.chatTools !== "allowed") {
+    const toolChoice = body.tool_choice;
+    const toolIntent = Array.isArray(body.tools) && body.tools.length > 0 || toolChoice !== void 0 && toolChoice !== null && toolChoice !== "none" && toolChoice !== "auto";
+    if (toolIntent && (descriptor.chatTools === "never" || activeReasoning)) {
+      fail(
+        "Chat Completions tool calling",
+        descriptor.chatTools === "never" ? `Use openai-responses:${model} for tools.` : `Use openai-responses:${model} for reasoning with tools, or set effective reasoning_effort to 'none'.`
+      );
+    }
+  }
+  if (activeReasoning) {
+    const forbidden = endpoint === "chat" ? ["temperature", "top_p", "top_logprobs", "logprobs"] : ["temperature", "top_p", "top_logprobs"];
+    for (const key of forbidden) {
+      if (body[key] !== void 0)
+        fail(key, `Remove ${key} or set reasoning effort to 'none' on Sol or Luna.`);
+    }
+    if (endpoint === "responses" && Array.isArray(body.include) && body.include.includes("message.output_text.logprobs")) {
+      fail(
+        "message.output_text.logprobs",
+        "Remove it from include or set reasoning effort to none on Sol or Luna."
+      );
+    }
+  }
 }
 function resolveOpenAIEffortResolution(options, resolveWireEffort, endpoint) {
   const resolved = resolveThinkingOptions(options);
@@ -3999,11 +4222,15 @@ function resolveOpenAIEffortResolution(options, resolveWireEffort, endpoint) {
   };
 }
 var openaiReasoningEmit = (body, resolved, model) => {
-  const oSeries = isOSeriesModel(model);
-  const reasoningCapable = supportsReasoningEffort(model);
   const wireEffort = resolveOpenAIChatReasoningEffort(model, resolved);
   if (wireEffort) body.reasoning_effort = wireEffort;
-  return { stripTemperature: oSeries || reasoningCapable && wireEffort !== void 0 };
+  return {
+    stripTemperature: stripsPortableSampling(
+      resolveOpenAIModelDescriptor(model),
+      "chat",
+      wireEffort
+    )
+  };
 };
 var OPENAI_PROFILE = {
   name: "openai",
@@ -4038,6 +4265,9 @@ var OpenAIProvider = class extends OpenAICompatibleProvider {
       "OpenAI Chat Completions"
     );
   }
+  validateFinalRequestBody(body) {
+    validateOpenAIFinalRequestBody(body, "chat");
+  }
   computeCost(model, usage, _reportedCost, context) {
     return usage ? estimateDirectOpenAICost(model, usage, { ...context, baseUrl: this.baseUrl }) : void 0;
   }
@@ -4310,12 +4540,12 @@ var OpenAIResponsesProvider = class {
   // ---------------------------------------------------------------------------
   buildRequestBody(messages, options, stream) {
     const effectiveModel = typeof options.providerOptions?.model === "string" ? options.providerOptions.model : options.model;
-    const oSeries = isOSeriesModel(effectiveModel);
-    const reasoningCapable = supportsReasoningEffort(effectiveModel);
+    const descriptor = resolveOpenAIModelDescriptor(effectiveModel);
+    const reasoningCapable = descriptor.reasoning;
     const resolved = resolveThinkingOptions(options);
     const { includeThoughts } = resolved;
     const wireEffort = resolveOpenAIReasoningEffort(effectiveModel, resolved);
-    const stripTemp = oSeries || supportsMaxReasoningEffort(effectiveModel) || reasoningCapable && wireEffort !== void 0;
+    const stripTemp = stripsPortableSampling(descriptor, "responses", wireEffort);
     const systemMessages = messages.filter((m) => m.role === "system");
     const nonSystemMessages = messages.filter((m) => m.role !== "system");
     const body = {
@@ -4364,6 +4594,7 @@ var OpenAIResponsesProvider = class {
     if (options.providerOptions) {
       Object.assign(body, options.providerOptions);
     }
+    validateOpenAIFinalRequestBody(body, "responses");
     return body;
   }
   requestModel(body, fallback) {
@@ -4678,6 +4909,36 @@ function anthropicImageBlocks(parts, model) {
 }
 var ANTHROPIC_API_VERSION = "2023-06-01";
 var ANTHROPIC_FILES_BETA = "files-api-2025-04-14";
+var ANTHROPIC_THINKING_BINDING_BETA = "thinking-binding-controls-2026-08-01";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasReplayedThinking(body) {
+  return Array.isArray(body.messages) && body.messages.some(
+    (message) => isRecord(message) && Array.isArray(message.content) && message.content.some(
+      (block) => isRecord(block) && (block.type === "thinking" || block.type === "redacted_thinking")
+    )
+  );
+}
+function hasFinalFileImage(body) {
+  return Array.isArray(body.messages) && body.messages.some(
+    (message) => isRecord(message) && Array.isArray(message.content) && message.content.some(
+      (block) => isRecord(block) && block.type === "image" && isRecord(block.source) && block.source.type === "file"
+    )
+  );
+}
+function normalizeThinkingDrops(value) {
+  if (!Array.isArray(value)) return void 0;
+  const reasons = {};
+  let droppedBlocks = 0;
+  for (const entry of value) {
+    if (!isRecord(entry) || entry.type !== "thinking_dropped") continue;
+    const reason = entry.reason === "prefix_binding_mismatch" || entry.reason === "model_binding_mismatch" || entry.reason === "organization_binding_mismatch" || entry.reason === "end_user_binding_mismatch" ? entry.reason : "other";
+    reasons[reason] = (reasons[reason] ?? 0) + 1;
+    droppedBlocks++;
+  }
+  return droppedBlocks > 0 ? { droppedBlocks, reasons } : void 0;
+}
 function hasAnthropicProviderFileImage(messages) {
   return messages.some(
     (message) => Array.isArray(message.content) && message.content.some(
@@ -4686,11 +4947,19 @@ function hasAnthropicProviderFileImage(messages) {
   );
 }
 var CLAUDE_CAPABILITIES = {
+  "claude-opus-5-5": {
+    thinking: "adaptive-always-on",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true,
+    thinkingBinding: true
+  },
   "claude-fable-5-1": {
     thinking: "adaptive-always-on",
     effortLevels: ["low", "medium", "high", "xhigh", "max"],
     manualBudget: false,
-    stripTemperature: true
+    stripTemperature: true,
+    thinkingBinding: true
   },
   "claude-fable-5": {
     thinking: "adaptive-always-on",
@@ -4784,6 +5053,7 @@ function resolveClaudeCapability(model) {
 }
 var DEFAULT_CACHE_READ_MULTIPLIER = 0.1;
 var ANTHROPIC_RATES = {
+  "claude-opus-5-5": { input: 4e-6, output: 2e-5, cacheReadMultiplier: 0.05 },
   "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
@@ -5218,11 +5488,12 @@ var AnthropicProvider = class {
   // chat - non-streaming completion
   // ---------------------------------------------------------------------------
   async chat(messages, options) {
+    const body = this.buildRequestBody(messages, options, false);
     const headers = this.buildHeaders(
       await this.resolveKey(),
-      hasAnthropicProviderFileImage(messages)
+      hasAnthropicProviderFileImage(messages) || hasFinalFileImage(body),
+      this.requiresBindingBeta(body)
     );
-    const body = this.buildRequestBody(messages, options, false);
     const pricingContext = pricingContextFromBody(body);
     const recorder = new CallTimingRecorder(options.requestLifecycle);
     const governor = this.governorFor(pricingContext.model ?? options.model);
@@ -5260,11 +5531,12 @@ var AnthropicProvider = class {
   // stream - SSE streaming completion
   // ---------------------------------------------------------------------------
   async *stream(messages, options) {
+    const body = this.buildRequestBody(messages, options, true);
     const headers = this.buildHeaders(
       await this.resolveKey(),
-      hasAnthropicProviderFileImage(messages)
+      hasAnthropicProviderFileImage(messages) || hasFinalFileImage(body),
+      this.requiresBindingBeta(body)
     );
-    const body = this.buildRequestBody(messages, options, true);
     const pricingContext = pricingContextFromBody(body);
     const recorder = new CallTimingRecorder(options.requestLifecycle);
     const governor = this.governorFor(pricingContext.model ?? options.model);
@@ -5306,12 +5578,61 @@ var AnthropicProvider = class {
   // ---------------------------------------------------------------------------
   // Internal: request building
   // ---------------------------------------------------------------------------
-  buildHeaders(apiKey, requiresFilesBeta = false) {
+  buildHeaders(apiKey, requiresFilesBeta = false, requiresBindingBeta = false) {
+    const betas = [
+      ...requiresFilesBeta ? [ANTHROPIC_FILES_BETA] : [],
+      ...requiresBindingBeta ? [ANTHROPIC_THINKING_BINDING_BETA] : []
+    ];
     return {
       "Content-Type": "application/json",
       "x-api-key": apiKey,
       "anthropic-version": ANTHROPIC_API_VERSION,
-      ...requiresFilesBeta ? { "anthropic-beta": ANTHROPIC_FILES_BETA } : {}
+      ...betas.length > 0 ? { "anthropic-beta": betas.join(",") } : {}
+    };
+  }
+  requiresBindingBeta(body) {
+    const thinking = body.thinking;
+    return resolveClaudeCapability(String(body.model))?.thinkingBinding === true && (hasReplayedThinking(body) || isRecord(thinking) && thinking.block_binding !== void 0);
+  }
+  validateAndBindFinalBody(body) {
+    const model = typeof body.model === "string" ? body.model : "";
+    if (resolveClaudeCapability(model)?.thinkingBinding !== true) return;
+    const reject = (option, remediation) => {
+      throw new UnsupportedModelOptionError({ provider: this.name, model, option, remediation });
+    };
+    const toolChoice = body.tool_choice;
+    if (isRecord(toolChoice) && (toolChoice.type === "any" || toolChoice.type === "tool")) {
+      reject("forced tool choice", "Use toolChoice: 'auto' or 'none' on this model.");
+    }
+    if (body.thinking !== void 0 && (!isRecord(body.thinking) || body.thinking.type !== "adaptive" || body.thinking.budget_tokens !== void 0)) {
+      reject(
+        "manual or disabled thinking",
+        "Use thinking: { type: 'adaptive' } and output_config.effort."
+      );
+    }
+    const outputConfig = body.output_config;
+    if (outputConfig !== void 0 && (!isRecord(outputConfig) || outputConfig.effort !== void 0 && !["low", "medium", "high", "xhigh", "max"].includes(String(outputConfig.effort)))) {
+      reject("output_config.effort", "Use low, medium, high, xhigh, or max effort.");
+    }
+    if (body.temperature !== void 0 && body.temperature !== 1) {
+      reject("temperature", "Omit temperature or use the default value 1.");
+    }
+    if (body.top_p !== void 0 && (typeof body.top_p !== "number" || body.top_p < 0.99 || body.top_p > 1)) {
+      reject("top_p", "Omit top_p or use a value from 0.99 to 1.");
+    }
+    if (body.top_k !== void 0) {
+      reject("top_k", "Omit top_k on this model.");
+    }
+    const replayed = hasReplayedThinking(body);
+    if (!replayed) return;
+    const thinking = isRecord(body.thinking) ? body.thinking : { type: "adaptive" };
+    const binding = thinking.block_binding;
+    if (binding !== void 0 && (!isRecord(binding) || binding.prefix_mismatch_behavior !== "error" && binding.prefix_mismatch_behavior !== "drop_block")) {
+      reject("thinking.block_binding", "Use prefix_mismatch_behavior: 'error' or 'drop_block'.");
+    }
+    body.thinking = {
+      ...thinking,
+      block_binding: binding ?? { prefix_mismatch_behavior: "drop_block" }
     };
   }
   /** Extract a human-readable message from an API error response body. */
@@ -5390,6 +5711,7 @@ ${jsonInstruction}` : jsonInstruction;
     if (options.providerOptions) {
       Object.assign(body, options.providerOptions);
     }
+    this.validateAndBindFinalBody(body);
     return body;
   }
   /**
@@ -5546,6 +5868,7 @@ ${jsonInstruction}` : jsonInstruction;
       }
     }
     const normalized = json.usage ? normalizeAnthropicUsage(json.usage) : void 0;
+    const reasoningContextReset = normalizeThinkingDrops(json.input_transformations);
     const effectiveModel = typeof json.model === "string" ? json.model : pricingContext.model;
     if (hasFallbackBoundary) {
       throw new Error(
@@ -5560,7 +5883,8 @@ ${jsonInstruction}` : jsonInstruction;
       usage: normalized?.usage,
       cost,
       costProvenance: tableEstimate(cost),
-      providerMetadata: thinkingBlocks.length > 0 && !hasFallbackBoundary ? { anthropicThinkingBlocks: thinkingBlocks } : void 0
+      providerMetadata: thinkingBlocks.length > 0 && !hasFallbackBoundary ? { anthropicThinkingBlocks: thinkingBlocks } : void 0,
+      ...reasoningContextReset ? { diagnostics: { reasoningContextReset } } : {}
     };
   }
   // ---------------------------------------------------------------------------
@@ -5582,6 +5906,7 @@ ${jsonInstruction}` : jsonInstruction;
     let hasFallbackBoundary = false;
     let hasFallbackIterationSignal = false;
     let refused = false;
+    let reasoningContextReset;
     const finalizeUsage = () => {
       const normalized = rawUsage ? normalizeAnthropicUsage(rawUsage) : void 0;
       usage = normalized?.usage;
@@ -5594,7 +5919,8 @@ ${jsonInstruction}` : jsonInstruction;
         usage,
         cost,
         costProvenance: tableEstimate(cost),
-        providerMetadata: thinkingBlocks.length > 0 && !hasFallbackBoundary && !hasFallbackIterationSignal ? { anthropicThinkingBlocks: thinkingBlocks } : void 0
+        providerMetadata: thinkingBlocks.length > 0 && !hasFallbackBoundary && !hasFallbackIterationSignal ? { anthropicThinkingBlocks: thinkingBlocks } : void 0,
+        ...reasoningContextReset ? { diagnostics: { reasoningContextReset } } : {}
       };
     };
     try {
@@ -5687,6 +6013,7 @@ ${jsonInstruction}` : jsonInstruction;
                 rawUsage = mergeAnthropicUsage(rawUsage, event.message.usage);
               }
               if (typeof event.message?.model === "string") effectiveModel = event.message.model;
+              reasoningContextReset = normalizeThinkingDrops(event.message?.input_transformations);
               const messageFallback = hasFallbackIteration(event.message?.usage?.iterations);
               if (isAnthropicResponseModifier(
                 "inference_geo",
@@ -5703,6 +6030,10 @@ ${jsonInstruction}` : jsonInstruction;
               break;
             }
             case "message_delta": {
+              const finalTransformations = event.input_transformations ?? event.delta?.input_transformations;
+              if (finalTransformations !== void 0) {
+                reasoningContextReset = normalizeThinkingDrops(finalTransformations);
+              }
               if (event.usage) {
                 rawUsage = mergeAnthropicUsage(rawUsage, event.usage);
                 finalizeUsage();
@@ -5931,7 +6262,31 @@ var GEMINI_PRICING = {
   },
   "gemini-3.8-flash": { input: 75e-8, cached: 75e-9, output: 375e-8 }
 };
+var GEMINI_FLASH_SUCCESSOR_PRICING = {
+  ...GEMINI_PRICING,
+  "gemini-3.6-flash": { input: 15e-7, cached: 15e-8, output: 75e-7 },
+  "gemini-3.7-flash": {
+    input: 15e-7,
+    cached: 15e-8,
+    output: 75e-7,
+    audioInput: 15e-7
+  },
+  "gemini-3.8-flash": { input: 15e-7, cached: 15e-8, output: 75e-7 }
+};
+var GEMINI_FLASH_SUCCESSOR_START_MS = Date.UTC(2027, 0, 1);
+function geminiRatesAtDispatch(at) {
+  return at < GEMINI_FLASH_SUCCESSOR_START_MS ? GEMINI_PRICING : GEMINI_FLASH_SUCCESSOR_PRICING;
+}
 var CANONICAL_GEMINI_BASE_URL = GEMINI_DEFAULT_BASE_URL;
+function geminiPricingTimingObserver(context, recorder) {
+  return {
+    ...recorder.observer,
+    onDispatch: (attempt, at) => {
+      context.rates = geminiRatesAtDispatch(at);
+      recorder.observer.onDispatch?.(attempt, at);
+    }
+  };
+}
 function isValidTokenCount2(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
@@ -6012,8 +6367,8 @@ function geminiInteractionErrorStatus(code) {
 function isEligibleGeminiPricing(context, hasDefinitiveStandardResponseTier, hasInvalidResponseTier) {
   return context.eligibleRequest && isStandardGeminiRequestTier(context.serviceTier) && hasDefinitiveStandardResponseTier && !hasInvalidResponseTier;
 }
-function estimateGeminiCost(model, usage) {
-  const pricing = GEMINI_PRICING[model];
+function estimateGeminiCost(model, usage, rates) {
+  const pricing = rates && Object.hasOwn(rates, model) ? rates[model] : void 0;
   const cached = usage.cachedTokens ?? 0;
   if (!pricing || !isValidTokenCount2(usage.inputTokens) || !isValidTokenCount2(usage.outputTokens) || !isValidTokenCount2(cached) || cached > usage.inputTokens) {
     return void 0;
@@ -6341,7 +6696,7 @@ var GeminiProvider = class {
       {
         governor: this.governorFor(pricingContext.model),
         provider: this.name,
-        timing: recorder.observer,
+        timing: geminiPricingTimingObserver(pricingContext, recorder),
         admission: options.dispatchAdmission
       }
     );
@@ -6384,7 +6739,7 @@ var GeminiProvider = class {
       {
         governor: this.governorFor(pricingContext.model),
         provider: this.name,
-        timing: recorder.observer,
+        timing: geminiPricingTimingObserver(pricingContext, recorder),
         admission: options.dispatchAdmission
       }
     );
@@ -6422,7 +6777,7 @@ var GeminiProvider = class {
       {
         governor: this.governorFor(pricingContext.model),
         provider: this.name,
-        timing: recorder.observer,
+        timing: geminiPricingTimingObserver(pricingContext, recorder),
         admission: options.dispatchAdmission
       }
     );
@@ -6458,7 +6813,7 @@ var GeminiProvider = class {
       {
         governor: this.governorFor(pricingContext.model),
         provider: this.name,
-        timing: recorder.observer,
+        timing: geminiPricingTimingObserver(pricingContext, recorder),
         admission: options.dispatchAdmission
       }
     );
@@ -6677,7 +7032,7 @@ var GeminiProvider = class {
     )) {
       return void 0;
     }
-    return estimateGeminiCost(effectiveModel, normalized.pricingUsage);
+    return estimateGeminiCost(effectiveModel, normalized.pricingUsage, pricingContext.rates);
   }
   /**
    * Whether every model-produced step is text. A non-text reply part (image,
@@ -7262,7 +7617,7 @@ var GeminiProvider = class {
       pricingContext,
       isDefinitiveStandardGeminiResponseTier(json.usageMetadata?.serviceTier),
       json.usageMetadata?.serviceTier !== void 0 && !isDefinitiveStandardGeminiResponseTier(json.usageMetadata.serviceTier)
-    ) ? estimateGeminiCost(effectiveModel, normalized.pricingUsage) : void 0;
+    ) ? estimateGeminiCost(effectiveModel, normalized.pricingUsage, pricingContext.rates) : void 0;
     const rawParts = candidate?.content?.parts;
     const providerMetadata = rawParts ? { geminiParts: rawParts } : void 0;
     return {
@@ -7353,7 +7708,7 @@ var GeminiProvider = class {
         pricingContext,
         hasDefinitiveStandardResponseTier,
         hasInvalidResponseTier
-      ) ? estimateGeminiCost(effectiveModel, normalizedUsage.pricingUsage) : void 0;
+      ) ? estimateGeminiCost(effectiveModel, normalizedUsage.pricingUsage, pricingContext.rates) : void 0;
       yield {
         type: "done",
         usage: normalizedUsage?.usage,
@@ -9002,7 +9357,7 @@ var TranscriptionProviderRegistry = class {
 };
 
 // src/context.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 import { randomUUID } from "crypto";
 import { z, ZodError as ZodError2 } from "zod";
 
@@ -9266,6 +9621,95 @@ function sessionHistoryForAsk(history, normalizedInput) {
   return snapshot;
 }
 
+// src/compaction.ts
+import { createHash } from "crypto";
+var SUMMARY_SYSTEM_PROMPT = "Summarize the following conversation concisely, preserving key facts, decisions, and context needed for continuing the conversation.";
+var SUMMARY_MAX_TOKENS = 1024;
+function buildSummaryPrompt(messages, previousSummary) {
+  return [
+    ...previousSummary ? [`Previous conversation summary: ${previousSummary}`] : [],
+    ...messages.map((m) => `${m.role}: ${summarizeModelInput(m.content)}`)
+  ].join("\n");
+}
+function requestSummary(provider, options) {
+  return provider.chat(
+    [
+      { role: "system", content: SUMMARY_SYSTEM_PROMPT },
+      { role: "user", content: options.prompt }
+    ],
+    {
+      model: options.model,
+      maxTokens: SUMMARY_MAX_TOKENS,
+      ...options.signal ? { signal: options.signal } : {}
+    }
+  );
+}
+function summaryContextMessage(summary) {
+  return {
+    role: "system",
+    origin: "runtime",
+    content: `Summary of earlier conversation:
+${summary}`
+  };
+}
+function withoutAnthropicThinking(message) {
+  const metadata = message.providerMetadata;
+  if (!metadata || !Object.hasOwn(metadata, "anthropicThinkingBlocks")) return message;
+  const retainedMetadata = { ...metadata };
+  delete retainedMetadata.anthropicThinkingBlocks;
+  return {
+    ...message,
+    ...Object.keys(retainedMetadata).length > 0 ? { providerMetadata: retainedMetadata } : { providerMetadata: void 0 }
+  };
+}
+function anthropicThinkingBlockCount(message) {
+  const blocks = message.providerMetadata?.anthropicThinkingBlocks;
+  if (!Array.isArray(blocks)) return 0;
+  return blocks.filter(
+    (block) => block !== null && typeof block === "object" && (block.type === "thinking" || block.type === "redacted_thinking")
+  ).length;
+}
+function askSummaryMetaKey(agentName) {
+  return `askSummary:${agentName}`;
+}
+function isCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function parseAskSummaryRecord(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  if (typeof record.summary !== "string" || !isCount(record.coveredCount) || typeof record.prefixHash !== "string" || typeof record.summaryModelUri !== "string" || !isCount(record.invalidatedThinkingThrough) || record.sourceSummary !== void 0 && typeof record.sourceSummary !== "string") {
+    return void 0;
+  }
+  return {
+    summary: record.summary,
+    coveredCount: record.coveredCount,
+    prefixHash: record.prefixHash,
+    ...record.sourceSummary !== void 0 ? { sourceSummary: record.sourceSummary } : {},
+    summaryModelUri: record.summaryModelUri,
+    invalidatedThinkingThrough: record.invalidatedThinkingThrough
+  };
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function summaryPrefixHash(history, coveredCount) {
+  let canonical;
+  try {
+    canonical = JSON.stringify(
+      history.slice(0, coveredCount),
+      (_key, value) => isPlainObject(value) ? Object.fromEntries(
+        Object.keys(value).sort().map((key) => [key, value[key]])
+      ) : value
+    );
+  } catch {
+    return void 0;
+  }
+  return createHash("sha256").update(canonical).digest("hex");
+}
+
 // src/partial-json.ts
 var MAX_DEPTH = 256;
 function parsePartialJson(input) {
@@ -10902,9 +11346,9 @@ var LEGACY_REDACTION_RULES = {
   // which is user content or PII (field paths are schema-shape, preserved like
   // `string_delta.path`). Passthrough, as an explicit reviewed decision.
   schema_diagnostic: passthrough,
-  // `provider_diagnostic` carries only provider capability metadata — a provider
-  // name, a model id, and two effort level strings. No application data or user
-  // content ever reaches it. Passthrough, as an explicit reviewed decision.
+  // `provider_diagnostic` carries only provider/model metadata, effort levels,
+  // and bounded dropped-thinking reason counts. Raw transformation paths and
+  // signed thinking never enter this event. Passthrough is reviewed here.
   provider_diagnostic: passthrough,
   log: (e) => {
     if (!e.data || typeof e.data !== "object" || Array.isArray(e.data)) return e;
@@ -12534,9 +12978,8 @@ function recordToolSpanOutcome(span, outcome) {
 }
 
 // src/context.ts
-var signalStorage = new AsyncLocalStorage2();
-var hardSignalStorage = new AsyncLocalStorage2();
-var timeoutTrackerStorage = new AsyncLocalStorage2();
+var signalStorage = new AsyncLocalStorage3();
+var hardSignalStorage = new AsyncLocalStorage3();
 var MAX_TIMER_DELAY_MS = 2147483647;
 function composeAbortSignals(...signals) {
   const active = signals.filter((signal) => signal !== void 0);
@@ -12568,9 +13011,6 @@ function raceWithAbortSignal(promise, signal) {
     );
   });
 }
-function pausedHumanWaitMs(tracker, now = Date.now()) {
-  return tracker.humanWaitMs + (tracker.activeHumanWaits > 0 && tracker.humanWaitStartedAt !== void 0 ? now - tracker.humanWaitStartedAt : 0);
-}
 var DEFAULT_BRANCH_DRAIN_TIMEOUT_MS = 5e3;
 function resolveBranchDrainTimeoutMs(value) {
   const resolved = value === void 0 ? DEFAULT_BRANCH_DRAIN_TIMEOUT_MS : value;
@@ -12641,7 +13081,7 @@ function parseHumanDecision(value) {
   }
   return invalid3();
 }
-var askStorage = new AsyncLocalStorage2();
+var askStorage = new AsyncLocalStorage3();
 var inlineSchemaCache = /* @__PURE__ */ new WeakMap();
 function zodToJsonSchema(schema) {
   const cached = inlineSchemaCache.get(schema);
@@ -12913,7 +13353,14 @@ var WorkflowContext = class _WorkflowContext {
    *  suppresses late branch events after bounded finalization. */
   workflowLifecycleState;
   signal;
-  summaryCache;
+  /** Durable summary of messages removed by Session.history.maxMessages. */
+  sessionSummary;
+  /** Per-agent `maxContext` summaries, keyed by agent name. `null` records a
+   *  store lookup that found nothing. Mirrored to session metadata
+   *  (`askSummary:<agent>`) when this execution belongs to a session, so a
+   *  later execution can reuse the same exact-prefix boundary. Never the
+   *  durable `sessionSummary`. */
+  askSummaries = /* @__PURE__ */ new Map();
   /** 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
@@ -13089,7 +13536,7 @@ var WorkflowContext = class _WorkflowContext {
       endEmitted: false
     };
     if (init.metadata?.summaryCache) {
-      this.summaryCache = init.metadata.summaryCache;
+      this.sessionSummary = init.metadata.summaryCache;
     }
   }
   /**
@@ -13578,10 +14025,7 @@ var WorkflowContext = class _WorkflowContext {
     return hardAskSignal ? hardSignalStorage.run(hardAskSignal, runWithAskSignal) : runWithAskSignal();
   }
   async executeAgentCall(agent2, input, options, handoffMessages, usageCapture, sessionHistory = normalizeSessionHistory(this.sessionHistory)) {
-    const tracker = { humanWaitMs: 0, activeHumanWaits: 0 };
-    const enclosing = timeoutTrackerStorage.getStore() ?? [];
-    return timeoutTrackerStorage.run(
-      [...enclosing, tracker],
+    return runWithAskClock(
       () => this.executeAgentCallImpl(
         agent2,
         input,
@@ -13717,6 +14161,7 @@ var WorkflowContext = class _WorkflowContext {
     if (systemPrompt) {
       messages.push({ role: "system", content: systemPrompt });
     }
+    const cachedSummaryMessage = this.sessionSummary ? summaryContextMessage(this.sessionSummary) : void 0;
     const maxContext = agent2._config.maxContext;
     if (maxContext && sessionHistory.length > 0) {
       const reserveTokens = this.config.contextManagement?.reserveTokens ?? 2e3;
@@ -13741,22 +14186,44 @@ var WorkflowContext = class _WorkflowContext {
           }
         });
       }
-      if (historyEstimate.tokens > availableForHistory) {
-        const summarizedMessages = await this.summarizeHistory(
+      const summaryTokens = cachedSummaryMessage ? estimateMessagesTokens([cachedSummaryMessage]).tokens : 0;
+      if (historyEstimate.tokens + summaryTokens > availableForHistory) {
+        const projection = await this.summarizeHistory(
+          agent2._name,
+          modelUri,
           provider,
           model,
           sessionHistory,
           availableForHistory
         );
-        for (const msg of summarizedMessages) {
+        if (this.budgetContext?.exceeded && this.budgetContext.policy !== "warn") {
+          const { limit, totalCost: spent, policy } = this.budgetContext;
+          throw new BudgetExceededError(limit, spent, policy);
+        }
+        if (projection.removedThinkingBlocks > 0) {
+          this.emitEvent({
+            type: "provider_diagnostic",
+            agent: agent2._name,
+            data: {
+              kind: "reasoning_context_reset",
+              ...provider.name ? { provider: provider.name } : {},
+              model: typeof providerOptions?.model === "string" ? providerOptions.model : model,
+              droppedBlocks: projection.removedThinkingBlocks,
+              reasons: { client_prefix_rewrite: projection.removedThinkingBlocks }
+            }
+          });
+        }
+        for (const msg of projection.messages) {
           messages.push(msg);
         }
       } else {
+        if (cachedSummaryMessage) messages.push(cachedSummaryMessage);
         for (const msg of sessionHistory) {
           messages.push(msg);
         }
       }
     } else {
+      if (cachedSummaryMessage) messages.push(cachedSummaryMessage);
       for (const msg of sessionHistory) {
         messages.push(msg);
       }
@@ -13856,7 +14323,8 @@ ${appendedSchemaText}`;
       );
     }
     const startTime = Date.now();
-    const timeoutTracker = timeoutTrackerStorage.getStore()?.at(-1);
+    const askClock = currentAskClock();
+    const pausedAtStartMs = askClock ? pausedAskClockMs(askClock, startTime) : 0;
     const timingTotals = { turns: 0, queuedMs: 0, retryMs: 0, wireMs: 0 };
     const currentMessages = [...messages];
     let turns = 0;
@@ -13873,13 +14341,16 @@ ${appendedSchemaText}`;
     while (turns < maxTurns) {
       this.currentSignal?.throwIfAborted();
       const now = Date.now();
-      const elapsedMs = now - startTime - (timeoutTracker ? pausedHumanWaitMs(timeoutTracker, now) : 0);
-      if (elapsedMs > timeoutMs) {
+      const elapsedMs = now - startTime;
+      const pausedMs = askClock ? Math.max(0, pausedAskClockMs(askClock, now) - pausedAtStartMs) : 0;
+      const chargedMs = Math.max(0, elapsedMs - Math.min(pausedMs, Math.max(0, elapsedMs)));
+      if (chargedMs > timeoutMs) {
         throw new TimeoutError(
           "ctx.ask()",
           timeoutMs,
           timingTotals.turns > 0 ? {
             elapsedMs,
+            chargedMs,
             queuedMs: timingTotals.queuedMs,
             retryMs: timingTotals.retryMs,
             wireMs: timingTotals.wireMs,
@@ -14126,6 +14597,7 @@ ${appendedSchemaText}`;
                   usage: chunk.usage,
                   cost: chunk.cost,
                   providerMetadata: chunk.providerMetadata,
+                  diagnostics: chunk.diagnostics,
                   timing: chunk.timing
                 };
               }
@@ -14243,6 +14715,34 @@ ${appendedSchemaText}`;
         timingTotals.retryMs += response.timing.retryMs;
         timingTotals.wireMs += response.timing.wireMs;
       }
+      const reasoningReset = response.diagnostics?.reasoningContextReset;
+      if (reasoningReset && Number.isSafeInteger(reasoningReset.droppedBlocks) && reasoningReset.droppedBlocks > 0) {
+        const reasons = {};
+        for (const reason of [
+          "prefix_binding_mismatch",
+          "model_binding_mismatch",
+          "organization_binding_mismatch",
+          "end_user_binding_mismatch",
+          "client_prefix_rewrite",
+          "other"
+        ]) {
+          const count = reasoningReset.reasons?.[reason];
+          if (typeof count === "number" && Number.isSafeInteger(count) && count > 0) {
+            reasons[reason] = count;
+          }
+        }
+        this.emitEvent({
+          type: "provider_diagnostic",
+          agent: agent2._name,
+          data: {
+            kind: "reasoning_context_reset",
+            ...provider.name ? { provider: provider.name } : {},
+            model: typeof providerOptions?.model === "string" ? providerOptions.model : model,
+            droppedBlocks: reasoningReset.droppedBlocks,
+            reasons
+          }
+        });
+      }
       this.emitEvent({
         type: "agent_call_end",
         agent: agent2._name,
@@ -14985,31 +15485,65 @@ ${appendedSchemaText}`;
     }
     return defs;
   }
+  /** Session id for session-scoped ask-summary persistence, when this
+   *  execution belongs to a session and has a store to persist into. */
+  askSummarySessionId() {
+    const sessionId = this.metadata?.sessionId;
+    if (this.metadata?.sessionPersist === false) return void 0;
+    return this.stateStore && typeof sessionId === "string" && sessionId.length > 0 ? sessionId : void 0;
+  }
+  /** This agent's ask summary: the in-memory copy first, else the session's
+   *  persisted record (read once per execution). */
+  async loadAskSummary(agentName) {
+    if (this.askSummaries.has(agentName)) return this.askSummaries.get(agentName) ?? void 0;
+    const sessionId = this.askSummarySessionId();
+    const stored = sessionId ? parseAskSummaryRecord(
+      await this.stateStore.getSessionMeta(sessionId, askSummaryMetaKey(agentName))
+    ) : void 0;
+    this.askSummaries.set(agentName, stored ?? null);
+    return stored;
+  }
+  async saveAskSummary(agentName, record) {
+    this.askSummaries.set(agentName, record);
+    const sessionId = this.askSummarySessionId();
+    if (!sessionId) return;
+    const key = askSummaryMetaKey(agentName);
+    try {
+      await this.stateStore.saveSessionMeta(sessionId, key, record);
+    } catch (error) {
+      this.emitEvent({
+        type: "log",
+        agent: agentName,
+        data: {
+          warning: `Could not persist ask summary '${key}' for session '${sessionId}'; later executions will regenerate it. ` + (error instanceof Error ? error.message : String(error))
+        }
+      });
+    }
+  }
   /**
-   * Summarize old messages to fit within context window.
-   * Keeps recent messages intact, summarizes older ones.
+   * Project `history` into `availableTokens` for one agent's request: a summary
+   * of an exact covered prefix followed by every later message. Reuses the
+   * agent's cached boundary (in memory or persisted for the session) while the
+   * covered prefix, durable session summary, and summary model are unchanged
+   * and the whole tail fits; otherwise generates a new summary. Also reports how
+   * many Anthropic thinking blocks the projection removed from carried turns.
    */
-  async summarizeHistory(provider, model, history, availableTokens) {
-    if (this.summaryCache) {
-      const summaryMsg2 = {
-        role: "system",
-        origin: "runtime",
-        content: `Summary of earlier conversation:
-${this.summaryCache}`
-      };
-      const summaryTokens = estimateTokens(summarizeModelInput(summaryMsg2.content)) + 4;
-      const remaining = availableTokens - summaryTokens;
-      let recentTokens2 = 0;
-      let splitIdx2 = history.length;
-      for (let i = history.length - 1; i >= 0; i--) {
-        const msgTokens = estimateTokens(summarizeModelInput(history[i].content)) + 4;
-        if (recentTokens2 + msgTokens > remaining) break;
-        recentTokens2 += msgTokens;
-        splitIdx2 = i;
-      }
-      splitIdx2 = nextUserTurn(history, splitIdx2) ?? history.length;
-      if (splitIdx2 < history.length) {
-        return [summaryMsg2, ...history.slice(splitIdx2)];
+  async summarizeHistory(agentName, modelUri, provider, model, history, availableTokens) {
+    const summaryModelUri = this.config.contextManagement?.summaryModel ?? modelUri;
+    const cache = await this.loadAskSummary(agentName);
+    if (cache && cache.sourceSummary === this.sessionSummary && cache.summaryModelUri === summaryModelUri && cache.coveredCount <= history.length && cache.prefixHash === summaryPrefixHash(history, cache.coveredCount)) {
+      const summaryMsg = summaryContextMessage(cache.summary);
+      const summaryTokens = estimateTokens(summarizeModelInput(summaryMsg.content)) + 4;
+      const tail2 = history.slice(cache.coveredCount);
+      const tailTokens = estimateMessagesTokens(tail2).tokens;
+      if (summaryTokens + tailTokens <= availableTokens && (tail2.length === 0 || tail2[0].role === "user")) {
+        let removedThinkingBlocks = 0;
+        const projected = tail2.map((message, index) => {
+          if (cache.coveredCount + index >= cache.invalidatedThinkingThrough) return message;
+          removedThinkingBlocks += anthropicThinkingBlockCount(message);
+          return withoutAnthropicThinking(message);
+        });
+        return { messages: [summaryMsg, ...projected], removedThinkingBlocks };
       }
     }
     let recentTokens = 0;
@@ -15034,42 +15568,103 @@ ${this.summaryCache}`
     } else {
       splitIdx = history.length;
     }
-    if (splitIdx === 0) return history;
+    if (splitIdx === 0 && this.sessionSummary) splitIdx = history.length;
+    if (splitIdx === 0) return { messages: history, removedThinkingBlocks: 0 };
     const oldMessages = history.slice(0, splitIdx);
-    const summaryModelUri = this.config.contextManagement?.summaryModel;
+    const configuredSummaryModelUri = this.config.contextManagement?.summaryModel;
     let summaryProvider;
     let summaryModel;
-    if (summaryModelUri) {
-      const resolved = this.resolveProviderUri(summaryModelUri);
+    if (configuredSummaryModelUri) {
+      const resolved = this.resolveProviderUri(configuredSummaryModelUri);
       summaryProvider = resolved.provider;
       summaryModel = resolved.model;
     } else {
       summaryProvider = provider;
       summaryModel = model;
     }
-    const oldContent = oldMessages.map((m) => `${m.role}: ${summarizeModelInput(m.content)}`).join("\n");
-    const summaryResponse = await summaryProvider.chat(
-      [
-        {
-          role: "system",
-          content: "Summarize the following conversation concisely, preserving key facts, decisions, and context needed for continuing the conversation."
-        },
-        { role: "user", content: oldContent }
+    const summaryPrompt = buildSummaryPrompt(oldMessages, this.sessionSummary);
+    const summaryStart = Date.now();
+    this.emitEvent({
+      type: "agent_call_start",
+      agent: agentName,
+      model: summaryModelUri,
+      turn: 0,
+      data: {
+        purpose: "summary",
+        prompt: summaryPrompt,
+        system: SUMMARY_SYSTEM_PROMPT,
+        params: { maxTokens: SUMMARY_MAX_TOKENS },
+        turn: 0
+      }
+    });
+    let summaryResponse;
+    try {
+      this.currentSignal?.throwIfAborted();
+      summaryResponse = await requestSummary(summaryProvider, {
+        model: summaryModel,
+        prompt: summaryPrompt,
+        signal: this.currentSignal
+      });
+    } catch (error) {
+      const providerError = error instanceof ProviderError ? error : void 0;
+      this.emitEvent({
+        type: "agent_call_end",
+        agent: agentName,
+        model: summaryModelUri,
+        duration: Date.now() - summaryStart,
+        ...providerError?.timing ? { timing: providerError.timing } : {},
+        data: {
+          purpose: "summary",
+          response: "",
+          turn: 0,
+          // Provider errors may echo the summarized history, so the event
+          // uses a fixed projection even when trace redaction is disabled.
+          error: "Context-management summary call failed",
+          ...providerError ? { status: providerError.status, retryable: providerError.retryable } : {}
+        }
+      });
+      throw error;
+    }
+    if (isUsableCost2(summaryResponse.cost)) this._accumulateBudgetCost(summaryResponse.cost);
+    this.emitEvent({
+      type: "agent_call_end",
+      agent: agentName,
+      model: summaryModelUri,
+      cost: summaryResponse.cost,
+      ...!isUsableCost2(summaryResponse.cost) ? { unpriced: true } : {},
+      tokens: summaryResponse.usage ? {
+        input: summaryResponse.usage.prompt_tokens,
+        output: summaryResponse.usage.completion_tokens,
+        reasoning: summaryResponse.usage.reasoning_tokens,
+        cached: summaryResponse.usage.cached_tokens,
+        cacheWrite: summaryResponse.usage.cache_write_tokens
+      } : void 0,
+      duration: Date.now() - summaryStart,
+      ...summaryResponse.timing ? { timing: summaryResponse.timing } : {},
+      data: { purpose: "summary", response: summaryResponse.content, turn: 0 }
+    });
+    const prefixHash = summaryPrefixHash(history, splitIdx);
+    if (prefixHash) {
+      await this.saveAskSummary(agentName, {
+        summary: summaryResponse.content,
+        coveredCount: splitIdx,
+        prefixHash,
+        ...this.sessionSummary !== void 0 ? { sourceSummary: this.sessionSummary } : {},
+        summaryModelUri,
+        invalidatedThinkingThrough: history.length
+      });
+    }
+    const tail = history.slice(splitIdx);
+    return {
+      messages: [
+        summaryContextMessage(summaryResponse.content),
+        ...tail.map(withoutAnthropicThinking)
       ],
-      { model: summaryModel, maxTokens: 1024, signal: this.currentSignal }
-    );
-    this.summaryCache = summaryResponse.content;
-    const sessionId = this.metadata?.sessionId;
-    if (sessionId && this.stateStore) {
-      await this.stateStore.saveSessionMeta(sessionId, "summaryCache", this.summaryCache);
-    }
-    const summaryMsg = {
-      role: "system",
-      origin: "runtime",
-      content: `Summary of earlier conversation:
-${summaryResponse.content}`
+      removedThinkingBlocks: tail.reduce(
+        (count, message) => count + anthropicThinkingBlockCount(message),
+        0
+      )
     };
-    return [summaryMsg, ...history.slice(splitIdx)];
   }
   // ── ctx.checkpoint() ────────────────────────────────────────────────
   /**
@@ -15749,12 +16344,7 @@ ${summaryResponse.content}`
   }
   // ── ctx.awaitHuman() ──────────────────────────────────────────────────
   async awaitHuman(options) {
-    const trackers = timeoutTrackerStorage.getStore();
-    const startedAt = Date.now();
-    for (const tracker of trackers ?? []) {
-      if (tracker.activeHumanWaits++ === 0) tracker.humanWaitStartedAt = startedAt;
-    }
-    try {
+    return pauseAskClocks(async () => {
       if (this.spanManager) {
         return await this.spanManager.withSpanAsync(
           "axl.ctx.awaitHuman",
@@ -15771,16 +16361,7 @@ ${summaryResponse.content}`
         );
       }
       return await this._awaitHumanImpl(options);
-    } finally {
-      const finishedAt = Date.now();
-      for (const tracker of trackers ?? []) {
-        tracker.activeHumanWaits--;
-        if (tracker.activeHumanWaits === 0 && tracker.humanWaitStartedAt !== void 0) {
-          tracker.humanWaitMs += finishedAt - tracker.humanWaitStartedAt;
-          tracker.humanWaitStartedAt = void 0;
-        }
-      }
-    }
+    });
   }
   async _awaitHumanImpl(options) {
     const branchSignal = this.currentSignal;
@@ -16777,7 +17358,7 @@ function workflow(config) {
 // src/runtime.ts
 import { EventEmitter as EventEmitter2 } from "events";
 import { randomUUID as randomUUID4 } from "crypto";
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "async_hooks";
 import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { dirname } from "path";
 
@@ -17492,17 +18073,17 @@ var Session = class _Session {
           throw new Error("SessionOptions.history.summaryModel is required when summarize is true");
         }
         const messagesToDrop = history.slice(0, history.length - maxMessages);
-        const toSummarize = cachedSummary ? [
-          { role: "system", content: `Previous conversation summary: ${cachedSummary}` },
-          ...messagesToDrop
-        ] : messagesToDrop;
-        const summary = await this.runtime.summarizeMessages(toSummarize, summaryModel);
+        const summary = await this.runtime.summarizeMessages(
+          messagesToDrop,
+          summaryModel,
+          cachedSummary ? { previousSummary: cachedSummary } : void 0
+        );
         await this.store.saveSessionMeta(this.sessionId, "summaryCache", summary);
         cachedSummary = summary;
       }
       const trimmed = history.slice(-maxMessages);
       history.length = 0;
-      history.push(...trimmed);
+      history.push(...trimmed.map(withoutAnthropicThinking));
     }
     const userMessage = { role: "user", content: preparedInput.content };
     history.push(userMessage);
@@ -17512,7 +18093,10 @@ var Session = class _Session {
     const metadata = {
       sessionId: this.sessionId,
       sessionHistory: history,
-      ...cachedSummary ? { summaryCache: cachedSummary } : {}
+      ...cachedSummary ? { summaryCache: cachedSummary } : {},
+      // An opted-out session must leave nothing at rest, including the
+      // agent-scoped ask-summary records the runtime would otherwise cache.
+      ...this.options.persist === false ? { sessionPersist: false } : {}
     };
     return { history, metadata };
   }
@@ -18966,7 +19550,7 @@ function assertNoRemovedObservationCallbacks(options) {
     `runtime.createContext() no longer accepts ${removed.join(", ")}. Observe ctx.events or use runtime.stream() instead. See docs/migration/stream-first-observation.md.`
   );
 }
-var costScopeStorage = new AsyncLocalStorage3();
+var costScopeStorage = new AsyncLocalStorage4();
 function forwardAbortSignal(external, internal) {
   if (!external) return () => {
   };
@@ -20594,22 +21178,17 @@ var AxlRuntime = class extends EventEmitter2 {
   /**
    * Summarize a list of chat messages into a concise summary string.
    * Used by Session to summarize dropped messages when history.summarize is enabled.
+   * `previousSummary` is folded in so a rolling summary never loses what it
+   * alone still carries. Shares its prompt and provider call with the
+   * `AgentConfig.maxContext` summarizer (see `compaction.ts`). It runs outside
+   * any workflow execution, so it emits no ask-scoped events.
    */
-  async summarizeMessages(messages, modelUri) {
+  async summarizeMessages(messages, modelUri, options) {
     const { provider, model } = this.resolveProvider(modelUri);
-    const response = await provider.chat(
-      [
-        {
-          role: "system",
-          content: "Summarize the following conversation concisely, preserving key facts, decisions, and context needed for continuing the conversation."
-        },
-        {
-          role: "user",
-          content: messages.map((m) => `${m.role}: ${summarizeModelInput(m.content)}`).join("\n")
-        }
-      ],
-      { model, maxTokens: 1024 }
-    );
+    const response = await requestSummary(provider, {
+      model,
+      prompt: buildSummaryPrompt(messages, options?.previousSummary)
+    });
     return response.content;
   }
   /** Get the state store (for testing and advanced use cases). */
@@ -22039,6 +22618,7 @@ export {
   TranscriptionProviderRegistry,
   UnsupportedEventSchemaVersionError,
   UnsupportedModelInputError,
+  UnsupportedModelOptionError,
   UnsupportedTranscriptionInputError,
   VLLM_PROFILE,
   ValidationError,