@axlsdk/axl 0.25.0 → 0.25.2

package/dist/index.cjs

@@ -184,6 +184,7 @@ __export(index_exports, {
   TranscriptionProviderRegistry: () => TranscriptionProviderRegistry,
   UnsupportedEventSchemaVersionError: () => UnsupportedEventSchemaVersionError,
   UnsupportedModelInputError: () => UnsupportedModelInputError,
+  UnsupportedModelOptionError: () => UnsupportedModelOptionError,
   UnsupportedTranscriptionInputError: () => UnsupportedTranscriptionInputError,
   VLLM_PROFILE: () => VLLM_PROFILE,
   ValidationError: () => ValidationError,
@@ -272,6 +273,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);
@@ -563,7 +581,7 @@ var sharedGuard = typeof installedGuard === "object" && installedGuard !== null
 var buildPath = typeof __AXL_BUILD_PATH__ === "string" ? __AXL_BUILD_PATH__ : "<source>";
 var thisCopy = {
   path: buildPath.startsWith("file:") ? (0, import_node_url.fileURLToPath)(buildPath) : buildPath,
-  version: true ? "0.25.0" : "unknown"
+  version: true ? "0.25.2" : "unknown"
 };
 function warnCrossCopy(other, joined) {
   if (other === thisCopy) return;
@@ -3436,8 +3454,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 = {
@@ -3845,6 +3867,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",
@@ -4175,7 +4215,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) {
@@ -4200,57 +4240,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);
@@ -4266,11 +4455,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",
@@ -4305,6 +4498,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;
   }
@@ -4577,12 +4773,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 = {
@@ -4631,6 +4827,7 @@ var OpenAIResponsesProvider = class {
     if (options.providerOptions) {
       Object.assign(body, options.providerOptions);
     }
+    validateOpenAIFinalRequestBody(body, "responses");
     return body;
   }
   requestModel(body, fallback) {
@@ -4945,6 +5142,47 @@ 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 isFinalThinkingAdaptive(capability, body) {
+  const thinking = body.thinking;
+  if (thinking === void 0) {
+    return capability.thinking === "adaptive-default-on" || capability.thinking === "adaptive-always-on";
+  }
+  return isRecord(thinking) && thinking.type === "adaptive";
+}
+var NATIVE_CLAUDE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+function isNativeClaudeEffort(value) {
+  return NATIVE_CLAUDE_EFFORTS.includes(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(
@@ -4953,11 +5191,51 @@ function hasAnthropicProviderFileImage(messages) {
   );
 }
 var CLAUDE_CAPABILITIES = {
+  // Thinking off is `between_tools` (progress updates between tool calls);
+  // `disabled` is a provider 400. Forced tool choice is a 400.
+  "claude-sonnet-5-5": {
+    thinking: "adaptive-default-on",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true,
+    disableAt: "high",
+    offShape: "between_tools",
+    forcedToolChoice: "rejected",
+    defaultOnlySampling: true,
+    strictThinking: true,
+    thinkingBinding: true
+  },
+  // Thinking off is `disabled`, only at effort high or below. Forced tool
+  // choice is accepted (the provider skips thinking for that turn).
+  "claude-haiku-5-5": {
+    thinking: "adaptive-default-on",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true,
+    disableAt: "high",
+    defaultOnlySampling: true,
+    strictThinking: true,
+    thinkingBinding: true
+  },
+  "claude-opus-5-5": {
+    thinking: "adaptive-always-on",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true,
+    forcedToolChoice: "rejected",
+    defaultOnlySampling: true,
+    strictThinking: true,
+    thinkingBinding: true
+  },
   "claude-fable-5-1": {
     thinking: "adaptive-always-on",
     effortLevels: ["low", "medium", "high", "xhigh", "max"],
     manualBudget: false,
-    stripTemperature: true
+    stripTemperature: true,
+    forcedToolChoice: "rejected",
+    defaultOnlySampling: true,
+    strictThinking: true,
+    thinkingBinding: true
   },
   "claude-fable-5": {
     thinking: "adaptive-always-on",
@@ -5051,6 +5329,16 @@ function resolveClaudeCapability(model) {
 }
 var DEFAULT_CACHE_READ_MULTIPLIER = 0.1;
 var ANTHROPIC_RATES = {
+  // Sonnet 5.5 cache reads are 0.05x ($0.10/MTok): the pricing table, its
+  // footnote, the models overview, and the prompt-caching guide agree
+  // (re-checked 2026-10-07).
+  "claude-sonnet-5-5": { input: 2e-6, output: 1e-5, cacheReadMultiplier: 0.05 },
+  "claude-haiku-5-5": {
+    input: 1e-7,
+    output: 5e-7,
+    longPrompt: { aboveTokens: 1e5, card: { input: 5e-7, output: 25e-7 } }
+  },
+  "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
@@ -5112,14 +5400,16 @@ function estimateAnthropicCost(model, usage) {
     return void 0;
   }
   const cacheWriteTotal = safeTokenSum(cacheWrite5m, cacheWrite1h);
-  if (cacheWriteTotal === void 0 || safeTokenSum(usage.inputTokens, cacheRead, cacheWriteTotal) === void 0) {
+  const promptTokens = cacheWriteTotal === void 0 ? void 0 : safeTokenSum(usage.inputTokens, cacheRead, cacheWriteTotal);
+  if (cacheWriteTotal === void 0 || promptTokens === void 0) {
     return void 0;
   }
   if (usage.aggregateCacheWriteTokens !== void 0 && (!isValidTokenCount(usage.aggregateCacheWriteTokens) || usage.aggregateCacheWriteTokens !== cacheWriteTotal)) {
     return void 0;
   }
-  const { input, output } = rate;
-  const cacheReadRate = input * (rate.cacheReadMultiplier ?? DEFAULT_CACHE_READ_MULTIPLIER);
+  const card = rate.longPrompt && promptTokens > rate.longPrompt.aboveTokens ? rate.longPrompt.card : rate;
+  const { input, output } = card;
+  const cacheReadRate = input * (card.cacheReadMultiplier ?? DEFAULT_CACHE_READ_MULTIPLIER);
   return usage.inputTokens * input + cacheRead * cacheReadRate + cacheWrite5m * input * 1.25 + cacheWrite1h * input * 2 + usage.outputTokens * output;
 }
 var THINKING_BUDGETS = {
@@ -5181,7 +5471,7 @@ function resolveClaudeThinking(model, resolved) {
         };
       }
       return {
-        thinking: { type: "disabled" },
+        thinking: { type: capability.offShape ?? "disabled" },
         outputConfig: activeEffort ? { effort: activeEffort } : void 0,
         stripTemperature: true
       };
@@ -5485,11 +5775,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);
@@ -5527,11 +5818,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);
@@ -5573,14 +5865,119 @@ 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(",") } : {}
     };
   }
+  /**
+   * Whether the final body needs the binding beta header. Runs after
+   * `validateAndBindFinalBody`, which has already injected `block_binding`
+   * wherever it applies, so the header follows the final body rather than
+   * re-deriving the injection rule.
+   */
+  requiresBindingBeta(body) {
+    const capability = resolveClaudeCapability(String(body.model));
+    const thinking = body.thinking;
+    return capability?.thinkingBinding === true && isRecord(thinking) && thinking.type === "adaptive" && thinking.block_binding !== void 0;
+  }
+  /**
+   * Validate the final body (after `providerOptions`) against the effective
+   * model's capability, then inject `block_binding` where it applies. Every
+   * rule is gated on its own capability field and is a no-op when unset, so a
+   * model only gets the guards its provider contract calls for.
+   */
+  validateAndBindFinalBody(body) {
+    const model = typeof body.model === "string" ? body.model : "";
+    const capability = resolveClaudeCapability(model);
+    if (!capability) return;
+    const reject = (option, remediation) => {
+      throw new UnsupportedModelOptionError({ provider: this.name, model, option, remediation });
+    };
+    if (capability.forcedToolChoice === "rejected") {
+      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 (capability.strictThinking) {
+      const offShape = capability.thinking === "adaptive-always-on" ? void 0 : capability.offShape ?? "disabled";
+      const thinking = body.thinking;
+      const outputConfig = body.output_config;
+      const effort = isRecord(outputConfig) ? outputConfig.effort : void 0;
+      if (thinking !== void 0 && offShape === void 0) {
+        if (!isRecord(thinking) || thinking.type !== "adaptive" || thinking.budget_tokens !== void 0) {
+          reject(
+            "manual or disabled thinking",
+            "Use thinking: { type: 'adaptive' } and output_config.effort."
+          );
+        }
+      } else if (thinking !== void 0) {
+        if (!isRecord(thinking) || thinking.type !== "adaptive" && thinking.type !== offShape) {
+          reject(
+            "thinking.type",
+            `Use thinking: { type: 'adaptive' }, or { type: '${offShape}' } to turn thinking off.`
+          );
+        }
+        const record = thinking;
+        if (record.type === "adaptive" && record.budget_tokens !== void 0) {
+          reject("thinking.budget_tokens", "Use output_config.effort instead of budget_tokens.");
+        }
+        if (record.type === offShape) {
+          const extra = Object.keys(record).filter((key) => key !== "type");
+          if (extra.length > 0) {
+            reject(
+              `thinking.${offShape}.${extra[0]}`,
+              `Send thinking: { type: '${offShape}' } with no other fields.`
+            );
+          }
+        }
+      }
+      if (outputConfig !== void 0 && (!isRecord(outputConfig) || effort !== void 0 && !isNativeClaudeEffort(effort))) {
+        reject("output_config.effort", "Use low, medium, high, xhigh, or max effort.");
+      }
+      if (offShape !== void 0 && isRecord(thinking) && thinking.type === offShape && effort !== void 0 && capability.disableAt && !isEffortAtOrBelow(effort, capability.disableAt)) {
+        reject(
+          "output_config.effort",
+          `Thinking can be turned off only at effort '${capability.disableAt}' or below; lower the effort or use adaptive thinking.`
+        );
+      }
+    }
+    if (capability.defaultOnlySampling) {
+      if (body.temperature !== void 0 && body.temperature !== 1) {
+        reject("temperature", "Omit temperature or use the default value 1.");
+      }
+      if (body.top_p !== void 0 && body.top_p !== 0.99) {
+        reject("top_p", "Omit top_p or use the default value 0.99.");
+      }
+      if (body.temperature !== void 0 && body.top_p !== void 0) {
+        reject("temperature and top_p", "Send at most one of temperature and top_p.");
+      }
+      if (body.top_k !== void 0) {
+        reject("top_k", "Omit top_k on this model.");
+      }
+    }
+    if (capability.thinkingBinding === true && isFinalThinkingAdaptive(capability, body)) {
+      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'.");
+      }
+      if (hasReplayedThinking(body)) {
+        body.thinking = {
+          ...thinking,
+          block_binding: binding ?? { prefix_mismatch_behavior: "drop_block" }
+        };
+      }
+    }
+  }
   /** Extract a human-readable message from an API error response body. */
   extractErrorMessage(body, status) {
     try {
@@ -5657,6 +6054,7 @@ ${jsonInstruction}` : jsonInstruction;
     if (options.providerOptions) {
       Object.assign(body, options.providerOptions);
     }
+    this.validateAndBindFinalBody(body);
     return body;
   }
   /**
@@ -5813,6 +6211,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(
@@ -5827,7 +6226,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 } } : {}
     };
   }
   // ---------------------------------------------------------------------------
@@ -5849,6 +6249,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;
@@ -5861,7 +6262,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 {
@@ -5954,6 +6356,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",
@@ -5970,6 +6373,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();
@@ -6198,7 +6605,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;
 }
@@ -6279,8 +6710,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;
@@ -6608,7 +7039,7 @@ var GeminiProvider = class {
       {
         governor: this.governorFor(pricingContext.model),
         provider: this.name,
-        timing: recorder.observer,
+        timing: geminiPricingTimingObserver(pricingContext, recorder),
         admission: options.dispatchAdmission
       }
     );
@@ -6651,7 +7082,7 @@ var GeminiProvider = class {
       {
         governor: this.governorFor(pricingContext.model),
         provider: this.name,
-        timing: recorder.observer,
+        timing: geminiPricingTimingObserver(pricingContext, recorder),
         admission: options.dispatchAdmission
       }
     );
@@ -6689,7 +7120,7 @@ var GeminiProvider = class {
       {
         governor: this.governorFor(pricingContext.model),
         provider: this.name,
-        timing: recorder.observer,
+        timing: geminiPricingTimingObserver(pricingContext, recorder),
         admission: options.dispatchAdmission
       }
     );
@@ -6725,7 +7156,7 @@ var GeminiProvider = class {
       {
         governor: this.governorFor(pricingContext.model),
         provider: this.name,
-        timing: recorder.observer,
+        timing: geminiPricingTimingObserver(pricingContext, recorder),
         admission: options.dispatchAdmission
       }
     );
@@ -6944,7 +7375,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,
@@ -7529,7 +7960,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 {
@@ -7620,7 +8051,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,
@@ -9270,7 +9701,7 @@ var TranscriptionProviderRegistry = class {
 
 // src/context.ts
 var import_node_async_hooks3 = require("async_hooks");
-var import_node_crypto = require("crypto");
+var import_node_crypto2 = require("crypto");
 var import_zod2 = require("zod");
 
 // src/input.ts
@@ -9533,6 +9964,95 @@ function sessionHistoryForAsk(history, normalizedInput) {
   return snapshot;
 }
 
+// src/compaction.ts
+var import_node_crypto = require("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 (0, import_node_crypto.createHash)("sha256").update(canonical).digest("hex");
+}
+
 // src/partial-json.ts
 var MAX_DEPTH = 256;
 function parsePartialJson(input) {
@@ -11169,9 +11689,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;
@@ -13176,7 +13696,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
@@ -13352,7 +13879,7 @@ var WorkflowContext = class _WorkflowContext {
       endEmitted: false
     };
     if (init.metadata?.summaryCache) {
-      this.summaryCache = init.metadata.summaryCache;
+      this.sessionSummary = init.metadata.summaryCache;
     }
   }
   /**
@@ -13680,7 +14207,7 @@ var WorkflowContext = class _WorkflowContext {
       this._autoCheckpointName("ask", agentName),
       async () => {
         const parentFrame = askStorage.getStore();
-        const askId = (0, import_node_crypto.randomUUID)();
+        const askId = (0, import_node_crypto2.randomUUID)();
         const depth = (parentFrame?.depth ?? -1) + 1;
         const stepRef = parentFrame?.stepRef ?? this.stepRefRoot;
         const frame = {
@@ -13977,6 +14504,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;
@@ -14001,22 +14529,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);
       }
@@ -14117,6 +14667,7 @@ ${appendedSchemaText}`;
     }
     const startTime = Date.now();
     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;
@@ -14134,7 +14685,7 @@ ${appendedSchemaText}`;
       this.currentSignal?.throwIfAborted();
       const now = Date.now();
       const elapsedMs = now - startTime;
-      const pausedMs = askClock ? pausedAskClockMs(askClock, now) : 0;
+      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(
@@ -14389,6 +14940,7 @@ ${appendedSchemaText}`;
                   usage: chunk.usage,
                   cost: chunk.cost,
                   providerMetadata: chunk.providerMetadata,
+                  diagnostics: chunk.diagnostics,
                   timing: chunk.timing
                 };
               }
@@ -14506,6 +15058,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,
@@ -14556,7 +15136,7 @@ ${appendedSchemaText}`;
               const sourceFrame = askStorage.getStore();
               const handoffFromAskId = sourceFrame?.askId ?? this.executionId;
               const handoffSourceDepth = sourceFrame?.depth ?? 0;
-              const handoffToAskId = (0, import_node_crypto.randomUUID)();
+              const handoffToAskId = (0, import_node_crypto2.randomUUID)();
               const handoffTargetDepth = handoffSourceDepth + 1;
               const targetFrame = {
                 askId: handoffToAskId,
@@ -15248,31 +15828,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;
@@ -15297,42 +15911,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() ────────────────────────────────────────────────
   /**
@@ -16590,7 +17265,7 @@ ${summaryResponse.content}`
    * This operation never enters the chat history or chat-provider path. */
   async transcribe(request) {
     const startedAt = Date.now();
-    const transcriptionId = (0, import_node_crypto.randomUUID)();
+    const transcriptionId = (0, import_node_crypto2.randomUUID)();
     const signal = this.currentSignal;
     const rawAudio = request && typeof request === "object" && "audio" in request ? request.audio : void 0;
     const source = rawAudio?.type;
@@ -16979,7 +17654,7 @@ ${summaryResponse.content}`
 };
 
 // src/agent.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var agentCounter = 0;
 function agent(config) {
   agentCounter++;
@@ -17000,7 +17675,7 @@ function agent(config) {
       const transcriptionRegistry = new TranscriptionProviderRegistry();
       const ctx = new WorkflowContext({
         input: prompt,
-        executionId: (0, import_node_crypto2.randomUUID)(),
+        executionId: (0, import_node_crypto3.randomUUID)(),
         config: {},
         providerRegistry: registry2,
         transcriptionProviderRegistry: transcriptionRegistry
@@ -17025,7 +17700,7 @@ function workflow(config) {
 
 // src/runtime.ts
 var import_node_events2 = require("events");
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 var import_node_async_hooks4 = require("async_hooks");
 var import_node_fs3 = require("fs");
 var import_node_path3 = require("path");
@@ -17741,17 +18416,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);
@@ -17761,7 +18436,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 };
   }
@@ -18678,7 +19356,7 @@ function warnMissingMemoryMethodsOnce(stateStore) {
 var import_node_fs2 = require("fs");
 var import_promises = require("fs/promises");
 var import_node_readline = require("readline");
-var import_node_crypto3 = require("crypto");
+var import_node_crypto4 = require("crypto");
 var import_node_path2 = __toESM(require("path"), 1);
 var MANIFEST_FILE = "manifest.json";
 var RECORDS_FILE = "records.jsonl";
@@ -18743,7 +19421,7 @@ var FileDiagnosticArtifactStore = class {
   async writeManifest(manifest) {
     const dir = this.dir(manifest.artifactId);
     await (0, import_promises.mkdir)(dir, { recursive: true });
-    const temp = import_node_path2.default.join(dir, `${MANIFEST_FILE}.${(0, import_node_crypto3.randomUUID)()}.tmp`);
+    const temp = import_node_path2.default.join(dir, `${MANIFEST_FILE}.${(0, import_node_crypto4.randomUUID)()}.tmp`);
     await (0, import_promises.writeFile)(temp, JSON.stringify(manifest), "utf-8");
     await (0, import_promises.rename)(temp, import_node_path2.default.join(dir, MANIFEST_FILE));
   }
@@ -18780,7 +19458,7 @@ var FileDiagnosticArtifactStore = class {
     });
   }
   async stage(owner, opts) {
-    const artifactId = `art_${(0, import_node_crypto3.randomUUID)()}`;
+    const artifactId = `art_${(0, import_node_crypto4.randomUUID)()}`;
     const now = Date.now();
     await this.writeManifest({
       version: 1,
@@ -19981,7 +20659,7 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
     }
     try {
       await this.saveEvalResult({
-        id: resultObj.id ?? (0, import_node_crypto4.randomUUID)(),
+        id: resultObj.id ?? (0, import_node_crypto5.randomUUID)(),
         eval: name,
         timestamp: Date.now(),
         data: structuredClone(result)
@@ -20039,7 +20717,7 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
    */
   createContext(options) {
     assertNoRemovedObservationCallbacks(options);
-    const executionId = (0, import_node_crypto4.randomUUID)();
+    const executionId = (0, import_node_crypto5.randomUUID)();
     const budgetLimit = options?.budget ? parseCost(options.budget) : Infinity;
     this.registerWithCostScope(executionId);
     return new WorkflowContext({
@@ -20118,7 +20796,7 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
     }
     const validated = workflow2.inputSchema.parse(input);
     const branchDrainTimeoutMs = resolveBranchDrainTimeoutMs(options?.branchDrainTimeoutMs);
-    const executionId = (0, import_node_crypto4.randomUUID)();
+    const executionId = (0, import_node_crypto5.randomUUID)();
     const controller = new AbortController();
     this.abortControllers.set(executionId, controller);
     const cleanupAbortForwarder = forwardAbortSignal(options?.signal, controller);
@@ -20233,7 +20911,7 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
     const controller = new AbortController();
     axlStream.on("close", () => controller.abort());
     const cleanupAbortForwarder = forwardAbortSignal(options?.signal, controller);
-    const executionId = (0, import_node_crypto4.randomUUID)();
+    const executionId = (0, import_node_crypto5.randomUUID)();
     this.abortControllers.set(executionId, controller);
     let execInfo;
     let wfCtx;
@@ -20834,22 +21512,17 @@ var AxlRuntime = class extends import_node_events2.EventEmitter {
   /**
    * 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). */
@@ -22280,6 +22953,7 @@ function cosineSimilarity2(a, b) {
   TranscriptionProviderRegistry,
   UnsupportedEventSchemaVersionError,
   UnsupportedModelInputError,
+  UnsupportedModelOptionError,
   UnsupportedTranscriptionInputError,
   VLLM_PROFILE,
   ValidationError,