@genesislcap/ai-assistant 15.11.0 → 15.12.0

package/dist/chat-driver.cjs

@@ -19,10 +19,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/chat-driver-node.ts
 var chat_driver_node_exports = {};
 __export(chat_driver_node_exports, {
+  ANTHROPIC_CACHE_READ_MULTIPLIER: () => ANTHROPIC_CACHE_READ_MULTIPLIER,
+  ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER: () => ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER,
+  ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER: () => ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER,
   AgenticActivityBus: () => AgenticActivityBus,
   AnthropicProvider: () => AnthropicProvider,
   AnthropicTransport: () => AnthropicTransport,
   ChatDriver: () => ChatDriver,
+  GEMINI_CACHED_INPUT_MULTIPLIER: () => GEMINI_CACHED_INPUT_MULTIPLIER,
+  GEMINI_LONG_CONTEXT_THRESHOLD: () => GEMINI_LONG_CONTEXT_THRESHOLD,
   GeminiProvider: () => GeminiProvider,
   GeminiTransport: () => GeminiTransport,
   MutableAIProviderRegistry: () => MutableAIProviderRegistry,
@@ -31,17 +36,27 @@ __export(chat_driver_node_exports, {
   REQUEST_CONTINUATION_TOOL: () => REQUEST_CONTINUATION_TOOL,
   SUPPORTED_ANTHROPIC_MODEL_IDS: () => SUPPORTED_ANTHROPIC_MODEL_IDS,
   SUPPORTED_GEMINI_MODEL_IDS: () => SUPPORTED_GEMINI_MODEL_IDS,
+  addUsage: () => addUsage,
   agenticActivityBus: () => agenticActivityBus,
+  anthropicRatesFor: () => anthropicRatesFor,
+  anthropicTokenCost: () => anthropicTokenCost,
   assembleDebugLog: () => assembleDebugLog,
   buildTimelineEntries: () => buildTimelineEntries,
   clearSession: () => clearSession,
   defineAgent: () => defineAgent,
   defineStatefulAgent: () => defineStatefulAgent,
+  emptyUsage: () => emptyUsage,
   friendlyFallbackAgent: () => friendlyFallbackAgent,
+  geminiRatesFor: () => geminiRatesFor,
+  geminiTokenCost: () => geminiTokenCost,
   getMetaEvents: () => getMetaEvents,
   isObservableAIProviderRegistry: () => isObservableAIProviderRegistry,
   restoreMachine: () => restoreMachine,
-  strictFallbackAgent: () => strictFallbackAgent
+  strictFallbackAgent: () => strictFallbackAgent,
+  sumUsage: () => sumUsage,
+  totalTokens: () => totalTokens,
+  usageRows: () => usageRows,
+  vendorOfModel: () => vendorOfModel
 });
 module.exports = __toCommonJS(chat_driver_node_exports);
 
@@ -1105,6 +1120,13 @@ var SUPPORTED_ANTHROPIC_MODEL_IDS = [
   "claude-sonnet-4-6",
   "claude-haiku-4-5-20251001"
 ];
+function vendorOfModel(modelId) {
+  if (SUPPORTED_ANTHROPIC_MODEL_IDS.includes(modelId))
+    return "anthropic";
+  if (SUPPORTED_GEMINI_MODEL_IDS.includes(modelId))
+    return "gemini";
+  return void 0;
+}
 
 // ../../foundation-ai/dist/esm/utils/temperature.js
 var DEFAULT_ANCHOR = 0.5;
@@ -1113,6 +1135,106 @@ function scaleTemperature(normalized, { defaultTemp, maxTemp }) {
   return t <= DEFAULT_ANCHOR ? t / DEFAULT_ANCHOR * defaultTemp : defaultTemp + (t - DEFAULT_ANCHOR) / (1 - DEFAULT_ANCHOR) * (maxTemp - defaultTemp);
 }
 
+// ../../foundation-ai/dist/esm/utils/token-cost.js
+var TOKENS_PER_MILLION = 1e6;
+var ANTHROPIC_PRICING = {
+  "claude-haiku-4-5-20251001": { promptPerMillion: 1, candidatePerMillion: 5 },
+  // Fable 5 — Anthropic's most capable widely-released model; priced above Opus tier.
+  "claude-fable-5": { promptPerMillion: 10, candidatePerMillion: 50 },
+  // Opus 4.7 / 4.8 — same $5 / $25 per MTok. Stated per model rather than shared through a
+  // fall-through, so neither is ever "whatever was left over".
+  "claude-opus-4-8": { promptPerMillion: 5, candidatePerMillion: 25 },
+  "claude-opus-4-7": { promptPerMillion: 5, candidatePerMillion: 25 },
+  // Sonnet 5 is $2 / $10 — its OWN tier, and CHEAPER than the older Sonnet 4.6 below.
+  //
+  // This launched as an introductory rate through 2026-08-31, and an earlier version of this
+  // table deliberately charged the $3 / $15 standard rate instead, on the reasoning that the
+  // introductory period would lapse. Anthropic has since confirmed $2 / $10 as the permanent
+  // standard price and cancelled the scheduled increase, so that reasoning is dead and the old
+  // figure over-charged every Sonnet 5 request by 50%.
+  // https://platform.claude.com/docs/en/about-claude/pricing#model-pricing
+  "claude-sonnet-5": { promptPerMillion: 2, candidatePerMillion: 10 },
+  // Sonnet 4.6 remains on the older $3 / $15 Sonnet tier — the newer model is the cheaper one.
+  "claude-sonnet-4-6": { promptPerMillion: 3, candidatePerMillion: 15 }
+};
+function anthropicRatesFor(model) {
+  return ANTHROPIC_PRICING[model];
+}
+var ANTHROPIC_CACHE_READ_MULTIPLIER = 0.1;
+var ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER = 1.25;
+var ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER = 2;
+function anthropicTokenCost(model, usage) {
+  const { promptPerMillion, candidatePerMillion } = anthropicRatesFor(model);
+  const m = TOKENS_PER_MILLION;
+  const cacheWrite5mTokens = Math.max(0, usage.cacheWriteTokens - usage.cacheWrite1hTokens);
+  const promptCost = usage.uncachedInputTokens / m * promptPerMillion;
+  const cacheReadCost = usage.cacheReadTokens / m * promptPerMillion * ANTHROPIC_CACHE_READ_MULTIPLIER;
+  const cacheWriteCost = cacheWrite5mTokens / m * promptPerMillion * ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER + usage.cacheWrite1hTokens / m * promptPerMillion * ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER;
+  const candidateCost = usage.outputTokens / m * candidatePerMillion;
+  const cacheReadFull = usage.cacheReadTokens / m * promptPerMillion;
+  const cacheWriteFull = usage.cacheWriteTokens / m * promptPerMillion;
+  return {
+    costUsd: promptCost + cacheReadCost + cacheWriteCost + candidateCost,
+    savedUsd: cacheReadFull - cacheReadCost + (cacheWriteFull - cacheWriteCost),
+    breakdown: {
+      promptUsd: promptCost,
+      cacheReadUsd: cacheReadCost,
+      cacheWriteUsd: cacheWriteCost,
+      candidateUsd: candidateCost
+    }
+  };
+}
+var GEMINI_LONG_CONTEXT_THRESHOLD = 2e5;
+var GEMINI_CACHED_INPUT_MULTIPLIER = 0.1;
+var GEMINI_PRICING = {
+  "gemini-2.5-flash-lite": {
+    kind: "flat",
+    rate: { promptPerMillion: 0.1, candidatePerMillion: 0.4 }
+  },
+  "gemini-2.5-flash": { kind: "flat", rate: { promptPerMillion: 0.3, candidatePerMillion: 2.5 } },
+  "gemini-2.5-pro": {
+    kind: "tiered",
+    standard: { promptPerMillion: 1.25, candidatePerMillion: 10 },
+    longContext: { promptPerMillion: 2.5, candidatePerMillion: 15 }
+  },
+  "gemini-3.1-flash-lite": {
+    kind: "flat",
+    rate: { promptPerMillion: 0.25, candidatePerMillion: 1.5 }
+  },
+  "gemini-3.5-flash": { kind: "flat", rate: { promptPerMillion: 1.5, candidatePerMillion: 9 } },
+  "gemini-3.1-pro-preview": {
+    kind: "tiered",
+    standard: { promptPerMillion: 2, candidatePerMillion: 12 },
+    longContext: { promptPerMillion: 4, candidatePerMillion: 18 }
+  }
+};
+function geminiRatesFor(model, promptTokens) {
+  const pricing = GEMINI_PRICING[model];
+  if (pricing.kind === "flat") {
+    return pricing.rate;
+  }
+  return promptTokens > GEMINI_LONG_CONTEXT_THRESHOLD ? pricing.longContext : pricing.standard;
+}
+function geminiTokenCost(model, usage) {
+  const { promptPerMillion, candidatePerMillion } = geminiRatesFor(model, usage.promptTokens);
+  const m = TOKENS_PER_MILLION;
+  const uncachedPromptTokens = Math.max(0, usage.promptTokens - usage.cachedTokens);
+  const promptCost = uncachedPromptTokens / m * promptPerMillion;
+  const cacheReadCost = usage.cachedTokens / m * promptPerMillion * GEMINI_CACHED_INPUT_MULTIPLIER;
+  const candidateCost = (usage.candidateTokens + usage.thoughtTokens) / m * candidatePerMillion;
+  return {
+    costUsd: promptCost + cacheReadCost + candidateCost,
+    // Implicit caching has no write premium, so this is always >= 0.
+    savedUsd: usage.cachedTokens / m * promptPerMillion - cacheReadCost,
+    breakdown: {
+      promptUsd: promptCost,
+      cacheReadUsd: cacheReadCost,
+      cacheWriteUsd: 0,
+      candidateUsd: candidateCost
+    }
+  };
+}
+
 // ../../foundation-ai/dist/esm/utils/tool-schema.js
 var SCHEMA_MAP_KEYS = ["properties", "patternProperties", "$defs", "definitions"];
 var SCHEMA_LIST_KEYS = ["anyOf", "oneOf", "allOf", "prefixItems"];
@@ -1514,32 +1636,32 @@ function assertSupportedAnthropicModel(model) {
     throw new Error(`AnthropicTransport: unsupported model "${model}". Use one of: ${SUPPORTED_ANTHROPIC_MODEL_IDS.join(", ")}.`);
   }
 }
-function estimatedAnthropicRatesUsdPerMillion(model) {
-  if (model === "claude-haiku-4-5-20251001") {
-    return { promptPerMillion: 1, candidatePerMillion: 5 };
-  }
-  if (model === "claude-fable-5") {
-    return { promptPerMillion: 10, candidatePerMillion: 50 };
-  }
-  if (model === "claude-sonnet-5" || model === "claude-sonnet-4-6") {
-    return { promptPerMillion: 3, candidatePerMillion: 15 };
-  }
-  return { promptPerMillion: 5, candidatePerMillion: 25 };
-}
 function rejectsSamplingParams(model) {
   return model === "claude-fable-5" || model === "claude-opus-4-8" || model === "claude-opus-4-7" || model === "claude-sonnet-5";
 }
 function supportsNativeStructuredOutput(model) {
   return model === "claude-fable-5" || model === "claude-opus-4-8" || model === "claude-sonnet-5" || model === "claude-haiku-4-5-20251001";
 }
-function anthropicThinking(model) {
-  if (model !== "claude-sonnet-5" && model !== "claude-fable-5")
-    return void 0;
-  return { type: "adaptive", display: "summarized" };
+function supportsAdaptiveThinking(model) {
+  return model !== "claude-haiku-4-5-20251001";
 }
-var ANTHROPIC_CACHE_READ_MULTIPLIER = 0.1;
-var ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER = 1.25;
-var ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER = 2;
+function thinkingIsMandatory(model) {
+  return model === "claude-fable-5";
+}
+function anthropicThinking(model, policy) {
+  const defaultsToThinking = model === "claude-sonnet-5" || thinkingIsMandatory(model);
+  const adaptive = { type: "adaptive", display: "summarized" };
+  if (policy === "off") {
+    if (thinkingIsMandatory(model))
+      return adaptive;
+    return defaultsToThinking ? { type: "disabled" } : void 0;
+  }
+  if (policy === "auto") {
+    return supportsAdaptiveThinking(model) ? adaptive : void 0;
+  }
+  return defaultsToThinking ? adaptive : void 0;
+}
+var ANTHROPIC_PROVIDER_KEY = "anthropic";
 var ResponseTruncatedError = class extends Error {
   constructor(model, maxTokens, outputTokens, toolNames) {
     super(`Response truncated at ${maxTokens != null ? `the max_tokens cap (${maxTokens})` : "the model's output-token limit"} for model ${model}` + (toolNames.length > 0 ? ` while emitting tool call(s): ${toolNames.join(", ")}` : "") + ". The output exceeds the per-response limit \u2014 raise the provider maxTokens (where configurable) or split the work into smaller outputs.");
@@ -1551,10 +1673,30 @@ var ResponseTruncatedError = class extends Error {
   }
 };
 var AnthropicTransport = class _AnthropicTransport {
+  /**
+   * Warn once when a requested policy is silently clamped, in EITHER direction — which is what
+   * `ChatThinkingPolicy` promises callers. Both directions cost the caller something they asked
+   * for and would otherwise get no signal about: `'off'` on a model that always thinks keeps
+   * billing reasoning as output, and `'auto'` on a model without adaptive support means an agent
+   * that asked to reason quietly does not. (Gemini's twin deliberately stays silent on `'auto'`,
+   * but only because dynamic thinking is already the default there; Haiku defaults to none, so
+   * the same silence would hide a real difference.)
+   */
+  warnIfThinkingUnclampable(policy) {
+    if (this.warnedThinkingClamped)
+      return;
+    const clamped = policy === "off" && thinkingIsMandatory(this.model) || policy === "auto" && !supportsAdaptiveThinking(this.model);
+    if (!clamped)
+      return;
+    this.warnedThinkingClamped = true;
+    logger.warn(policy === "off" ? `AnthropicTransport: thinkingPolicy 'off' ignored \u2014 ${this.model} always thinks and rejects an explicit disable. Reasoning tokens are still billed as output; switch model if you need them gone.` : `AnthropicTransport: thinkingPolicy 'auto' ignored \u2014 ${this.model} does not support adaptive thinking, so this turn runs without reasoning. Use a Sonnet or Opus tier if the agent needs it.`);
+  }
   constructor(config = {}) {
     var _a, _b, _c, _d;
     this.lifetimeCostUsd = 0;
     this.lifetimeSavingsUsd = 0;
+    this.warnedThinkingClamped = false;
+    this.warnedUnknownServingModels = /* @__PURE__ */ new Set();
     const model = (_a = config.model) !== null && _a !== void 0 ? _a : DEFAULT_MODEL;
     assertSupportedAnthropicModel(model);
     this.model = model;
@@ -1635,8 +1777,12 @@ var AnthropicTransport = class _AnthropicTransport {
   // ── ChatTransport (multi-turn chat) ────────────────────────────────────
   sendChatMessage(history, userMessage, options) {
     return __awaiter(this, void 0, void 0, function* () {
-      var _a, _b, _c;
-      const messages = this.toAnthropicMessages(history, userMessage, options === null || options === void 0 ? void 0 : options.attachments);
+      var _a, _b, _c, _d;
+      const reachableModels = /* @__PURE__ */ new Set([
+        this.model,
+        ...((_a = options === null || options === void 0 ? void 0 : options.fallbacks) !== null && _a !== void 0 ? _a : []).map((f) => f.model)
+      ]);
+      const messages = this.toAnthropicMessages(history, userMessage, options === null || options === void 0 ? void 0 : options.attachments, reachableModels);
       const body = {
         model: this.model,
         max_tokens: this.maxTokens,
@@ -1644,18 +1790,20 @@ var AnthropicTransport = class _AnthropicTransport {
       };
       if (options === null || options === void 0 ? void 0 : options.systemPrompt)
         body.system = options.systemPrompt;
-      if ((_a = options === null || options === void 0 ? void 0 : options.tools) === null || _a === void 0 ? void 0 : _a.length) {
+      if ((_b = options === null || options === void 0 ? void 0 : options.tools) === null || _b === void 0 ? void 0 : _b.length) {
         body.tools = options.tools.map((t) => Object.assign({ name: t.name, description: t.description, input_schema: t.enforceSchema ? enforceAnthropicToolSchema(t.parameters, t.name) : t.parameters }, t.enforceSchema ? { strict: true } : {}));
       }
-      if ((_b = body.tools) === null || _b === void 0 ? void 0 : _b.length) {
+      if ((_c = body.tools) === null || _c === void 0 ? void 0 : _c.length) {
         const toolChoice = toAnthropicToolChoice(options === null || options === void 0 ? void 0 : options.toolChoice);
         if (toolChoice)
           body.tool_choice = toolChoice;
       }
-      const thinking = anthropicThinking(this.model);
+      this.warnIfThinkingUnclampable(options === null || options === void 0 ? void 0 : options.thinkingPolicy);
+      const thinking = anthropicThinking(this.model, options === null || options === void 0 ? void 0 : options.thinkingPolicy);
       if (thinking)
         body.thinking = thinking;
-      if ((options === null || options === void 0 ? void 0 : options.temperature) != null && !rejectsSamplingParams(this.model)) {
+      const thinkingEnabled = (thinking === null || thinking === void 0 ? void 0 : thinking.type) === "adaptive";
+      if ((options === null || options === void 0 ? void 0 : options.temperature) != null && !rejectsSamplingParams(this.model) && !thinkingEnabled) {
         body.temperature = scaleTemperature(options.temperature, {
           defaultTemp: ANTHROPIC_DEFAULT_TEMPERATURE,
           maxTemp: ANTHROPIC_MAX_TEMPERATURE
@@ -1666,7 +1814,7 @@ var AnthropicTransport = class _AnthropicTransport {
           format: { type: "json_schema", schema: options.responseSchema }
         };
       }
-      if ((_c = options === null || options === void 0 ? void 0 : options.fallbacks) === null || _c === void 0 ? void 0 : _c.length) {
+      if ((_d = options === null || options === void 0 ? void 0 : options.fallbacks) === null || _d === void 0 ? void 0 : _d.length) {
         body.fallbacks = options.fallbacks.map((f) => f.maxTokens != null ? { model: f.model, max_tokens: f.maxTokens } : { model: f.model });
       }
       if (options === null || options === void 0 ? void 0 : options.cachePolicy) {
@@ -1737,31 +1885,27 @@ var AnthropicTransport = class _AnthropicTransport {
    * and returns the per-call total so the caller can attach it to the response
    * message.
    */
-  logTokenUsage(promptTokens, candidateTokens, cacheReadTokens, cacheCreationTokens, cacheCreation1hTokens) {
-    const { promptPerMillion, candidatePerMillion } = estimatedAnthropicRatesUsdPerMillion(this.model);
-    const m = _AnthropicTransport.TOKENS_PER_MILLION;
-    const cacheCreation5mTokens = Math.max(0, cacheCreationTokens - cacheCreation1hTokens);
-    const promptCost = promptTokens / m * promptPerMillion;
-    const cacheReadCost = cacheReadTokens / m * promptPerMillion * ANTHROPIC_CACHE_READ_MULTIPLIER;
-    const cacheWriteCost = cacheCreation5mTokens / m * promptPerMillion * ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER + cacheCreation1hTokens / m * promptPerMillion * ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER;
-    const candidateCost = candidateTokens / m * candidatePerMillion;
-    const totalCost = promptCost + cacheReadCost + cacheWriteCost + candidateCost;
-    this.lifetimeCostUsd += totalCost;
-    const cacheReadFull = cacheReadTokens / m * promptPerMillion;
-    const cacheWriteFull = cacheCreationTokens / m * promptPerMillion;
-    const saved = cacheReadFull - cacheReadCost + (cacheWriteFull - cacheWriteCost);
-    this.lifetimeSavingsUsd += saved;
+  logTokenUsage(model, promptTokens, candidateTokens, cacheReadTokens, cacheCreationTokens, cacheCreation1hTokens) {
+    const { costUsd, savedUsd, breakdown } = anthropicTokenCost(model, {
+      uncachedInputTokens: promptTokens,
+      outputTokens: candidateTokens,
+      cacheReadTokens,
+      cacheWriteTokens: cacheCreationTokens,
+      cacheWrite1hTokens: cacheCreation1hTokens
+    });
+    this.lifetimeCostUsd += costUsd;
+    this.lifetimeSavingsUsd += savedUsd;
     const dp = _AnthropicTransport.COST_DECIMAL_PLACES;
-    console.log(`--- Anthropic Token Usage (${this.model}) ---`);
-    console.log(`Prompt Tokens:    ${promptTokens} ($${promptCost.toFixed(dp)})`);
-    console.log(`Cache Read:       ${cacheReadTokens} ($${cacheReadCost.toFixed(dp)})`);
-    console.log(`Cache Write:      ${cacheCreationTokens} ($${cacheWriteCost.toFixed(dp)})`);
-    console.log(`Candidate Tokens: ${candidateTokens} ($${candidateCost.toFixed(dp)})`);
-    console.log(`Total Cost:       $${totalCost.toFixed(dp)}`);
-    console.log(`Cache Saved:      $${saved.toFixed(dp)} (lifetime $${this.lifetimeSavingsUsd.toFixed(dp)})`);
+    console.log(`--- Anthropic Token Usage (${model}) ---`);
+    console.log(`Prompt Tokens:    ${promptTokens} ($${breakdown.promptUsd.toFixed(dp)})`);
+    console.log(`Cache Read:       ${cacheReadTokens} ($${breakdown.cacheReadUsd.toFixed(dp)})`);
+    console.log(`Cache Write:      ${cacheCreationTokens} ($${breakdown.cacheWriteUsd.toFixed(dp)})`);
+    console.log(`Candidate Tokens: ${candidateTokens} ($${breakdown.candidateUsd.toFixed(dp)})`);
+    console.log(`Total Cost:       $${costUsd.toFixed(dp)}`);
+    console.log(`Cache Saved:      $${savedUsd.toFixed(dp)} (lifetime $${this.lifetimeSavingsUsd.toFixed(dp)})`);
     console.log(`Lifetime Cost:    $${this.lifetimeCostUsd.toFixed(dp)}`);
     console.log("--------------------------");
-    return totalCost;
+    return costUsd;
   }
   /**
    * Convert the internal `ChatMessage[]` history into Anthropic's message format.
@@ -1772,7 +1916,7 @@ var AnthropicTransport = class _AnthropicTransport {
    * Consecutive same-role turns are merged by the API but we merge here to keep
    * the payload tidy.
    */
-  toAnthropicMessages(history, userMessage, attachments) {
+  toAnthropicMessages(history, userMessage, attachments, reachableModels = /* @__PURE__ */ new Set([this.model])) {
     var _a, _b, _c;
     const messages = [];
     const pushBlock = (role, block) => {
@@ -1795,6 +1939,9 @@ var AnthropicTransport = class _AnthropicTransport {
         continue;
       }
       if ((_a = msg.toolCalls) === null || _a === void 0 ? void 0 : _a.length) {
+        for (const block of this.reasoningToReplay(msg.toolCalls[0], reachableModels)) {
+          pushBlock("assistant", block);
+        }
         if (msg.content) {
           pushBlock("assistant", { type: "text", text: msg.content });
         }
@@ -1830,20 +1977,140 @@ ${att.content}` });
     }
     return messages;
   }
+  /**
+   * The blocks to replay ahead of a tool call — fallback boundaries then reasoning, or none.
+   *
+   * A `signature` is only valid for the model that produced it, so reasoning captured under a
+   * *different* model is normally dropped: an agent that varies `provider` by state can switch
+   * models mid-loop, and replaying the old model's signatures would send blocks the new one
+   * cannot verify.
+   *
+   * Two ways the producer can be the model that will validate:
+   *
+   * 1. **It is the model we are asking for.** `state.model === this.model` — the ordinary case.
+   * 2. **Sticky routing will send this conversation back to it.** After a conversation falls
+   *    back, later requests carrying `fallbacks` go straight to the model that served, without
+   *    re-running the one that declined. That is what makes a fallback producer's reasoning
+   *    replayable at all (Fable 5 configured, Opus 4.8 serving — the pairing this transport's
+   *    own constructor warning recommends). But it holds only while the conversation continues
+   *    under the SAME request configuration, which is why `requestedModel` is compared rather
+   *    than just checking the chain for the producer.
+   *
+   * That second condition is deliberately narrow. Chain membership alone is too weak: a
+   * fallback target is only *contingently* the server, so an agent that switches `provider` to
+   * a model whose own chain happens to contain the old producer would replay foreign
+   * signatures to whichever model actually answers. Requiring the requested model to be
+   * unchanged separates "this conversation is still going" from "we are somewhere else now".
+   *
+   * State captured before `requestedModel` existed falls back to condition 1 alone, which is
+   * the conservative branch — it can drop reasoning, never misdirect it.
+   *
+   * Boundaries themselves are always echoed: keeping them in place is the documented rule, and
+   * with no thinking blocks around them they are inert rather than harmful.
+   */
+  reasoningToReplay(firstCall, reachableModels) {
+    var _a, _b, _c;
+    const state = (_a = firstCall.providerMetadata) === null || _a === void 0 ? void 0 : _a[ANTHROPIC_PROVIDER_KEY];
+    if (!state)
+      return [];
+    const boundaries = (_b = state.fallbacks) !== null && _b !== void 0 ? _b : [];
+    const stickyToProducer = state.requestedModel === this.model && reachableModels.has(state.model);
+    const vouched = state.model === this.model || stickyToProducer;
+    return [...boundaries, ...vouched ? (_c = state.reasoning) !== null && _c !== void 0 ? _c : [] : []];
+  }
+  /**
+   * The model that actually served this response.
+   *
+   * A server-side `fallbacks` chain re-runs a declined request on another model and
+   * names it in the response's top-level `model`. Pricing must follow that, not the
+   * model we asked for: a Fable 5 request served by Opus 4.8 costed at Fable's
+   * $10/$50 instead of $5/$25 doubles that part of the bill.
+   *
+   * An unrecognised model id is NOT priced at a guessed rate — that is precisely how
+   * a consumer ended up billing Haiku at Sonnet rates. It warns and falls back to the
+   * configured model, which is at least a figure someone chose.
+   */
+  servingModel(response) {
+    const served = response.model;
+    if (!served || served === this.model)
+      return this.model;
+    if (SUPPORTED_ANTHROPIC_MODEL_IDS.includes(served)) {
+      return served;
+    }
+    if (!this.warnedUnknownServingModels.has(served)) {
+      this.warnedUnknownServingModels.add(served);
+      logger.warn(`AnthropicTransport: response was served by "${served}", which is not a known model \u2014 pricing it at the configured "${this.model}" rate instead of guessing. The reported cost for this request may be wrong; add the model to SUPPORTED_ANTHROPIC_MODEL_IDS.`);
+    }
+    return this.model;
+  }
+  /**
+   * Whether a fallback-chain attempt is a refusal that was **not billed**.
+   *
+   * Anthropic does not charge for a refusal that arrives before any output: the token counts
+   * still appear in `usage`, but they are not on the bill. Pricing them anyway turns the
+   * fallback undercount this reducer was written to fix into an overcount — the documented
+   * example declines with `input_tokens: 535, output_tokens: 0`, which is real money at
+   * Fable 5's prompt rate.
+   *
+   * A **mid-output** refusal *is* billed for the input and whatever it streamed, so output
+   * tokens are the discriminator rather than the refusal itself.
+   *
+   * Declined attempts appear as `type: 'message'`; the attempt that served the turn is
+   * `type: 'fallback_message'`. The serving entry is normally billable — except when every
+   * model in the chain declined, where the last entry is both the serving one and a refusal,
+   * which `lastAndRefused` covers.
+   *
+   * Also called for a response with no chain at all, as `isUnbilledRefusal({}, usage, refused)`:
+   * a direct request that was declined has no `iterations` array, and the same rule applies to
+   * it. That is in fact the common case — `iterations` only appears when `fallbacks` was
+   * configured.
+   */
+  isUnbilledRefusal(attempt, usage, lastAndRefused) {
+    var _a;
+    if (((_a = usage.output_tokens) !== null && _a !== void 0 ? _a : 0) > 0)
+      return false;
+    return attempt.type === "message" || lastAndRefused;
+  }
+  /** Cost one attempt's usage block at `model`'s rates, logging and banking it. */
+  costAttempt(model, usage) {
+    var _a, _b, _c, _d, _e, _f;
+    const cacheRead = (_a = usage.cache_read_input_tokens) !== null && _a !== void 0 ? _a : 0;
+    const breakdown = usage.cache_creation;
+    const cacheCreation1h = (_b = breakdown === null || breakdown === void 0 ? void 0 : breakdown.ephemeral_1h_input_tokens) !== null && _b !== void 0 ? _b : 0;
+    const cacheCreation = (_c = usage.cache_creation_input_tokens) !== null && _c !== void 0 ? _c : breakdown ? ((_d = breakdown.ephemeral_5m_input_tokens) !== null && _d !== void 0 ? _d : 0) + cacheCreation1h : 0;
+    return this.logTokenUsage(model, (_e = usage.input_tokens) !== null && _e !== void 0 ? _e : 0, (_f = usage.output_tokens) !== null && _f !== void 0 ? _f : 0, cacheRead, cacheCreation, cacheCreation1h);
+  }
   fromAnthropicResponse(response) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g;
     let inputTokens;
     let outputTokens;
     let cacheReadTokens;
     let cacheWriteTokens;
     let cost;
+    const servingModel = this.servingModel(response);
     if (response.usage) {
       const uncachedInput = (_a = response.usage.input_tokens) !== null && _a !== void 0 ? _a : 0;
       const cacheRead = (_b = response.usage.cache_read_input_tokens) !== null && _b !== void 0 ? _b : 0;
       const breakdown = response.usage.cache_creation;
       const cacheCreation1h = (_c = breakdown === null || breakdown === void 0 ? void 0 : breakdown.ephemeral_1h_input_tokens) !== null && _c !== void 0 ? _c : 0;
       const cacheCreation = (_d = response.usage.cache_creation_input_tokens) !== null && _d !== void 0 ? _d : breakdown ? ((_e = breakdown.ephemeral_5m_input_tokens) !== null && _e !== void 0 ? _e : 0) + cacheCreation1h : 0;
-      cost = this.logTokenUsage(uncachedInput, (_f = response.usage.output_tokens) !== null && _f !== void 0 ? _f : 0, cacheRead, cacheCreation, cacheCreation1h);
+      const attempts = response.usage.iterations;
+      if (attempts === null || attempts === void 0 ? void 0 : attempts.length) {
+        const refused = response.stop_reason === "refusal";
+        cost = attempts.reduce((total, attempt, index) => {
+          var _a2;
+          const usage = (_a2 = attempt.usage) !== null && _a2 !== void 0 ? _a2 : attempt;
+          if (this.isUnbilledRefusal(attempt, usage, index === attempts.length - 1 && refused)) {
+            return total;
+          }
+          const model = attempt.model ? this.servingModel({ model: attempt.model }) : this.model;
+          return total + this.costAttempt(model, usage);
+        }, 0);
+      } else if (this.isUnbilledRefusal({}, response.usage, response.stop_reason === "refusal")) {
+        cost = 0;
+      } else {
+        cost = this.costAttempt(servingModel, response.usage);
+      }
       inputTokens = uncachedInput + cacheRead + cacheCreation;
       cacheReadTokens = cacheRead;
       cacheWriteTokens = cacheCreation;
@@ -1851,23 +2118,44 @@ ${att.content}` });
         outputTokens = response.usage.output_tokens;
       }
     }
-    const blocks = (_g = response.content) !== null && _g !== void 0 ? _g : [];
+    const blocks = (_f = response.content) !== null && _f !== void 0 ? _f : [];
     const toolCalls = [];
     const thoughtParts = [];
     const textParts = [];
-    for (const block of blocks) {
+    const reasoningBlocks = [];
+    const fallbackIndex = blocks.map((b) => b.type).lastIndexOf("fallback");
+    const fallbackBlocks = blocks.filter((b) => b.type === "fallback");
+    for (const [index, block] of blocks.entries()) {
+      const postBoundary = index > fallbackIndex;
       if (block.type === "tool_use") {
-        toolCalls.push({
-          id: block.id,
-          name: block.name,
-          args: (_h = block.input) !== null && _h !== void 0 ? _h : {}
-        });
+        if (postBoundary) {
+          toolCalls.push({
+            id: block.id,
+            name: block.name,
+            args: (_g = block.input) !== null && _g !== void 0 ? _g : {}
+          });
+        }
       } else if (block.type === "thinking") {
+        if (postBoundary)
+          reasoningBlocks.push(block);
         thoughtParts.push(block.thinking);
+      } else if (block.type === "redacted_thinking") {
+        if (postBoundary)
+          reasoningBlocks.push(block);
       } else if (block.type === "text") {
         textParts.push(block.text);
       }
     }
+    if (toolCalls.length > 0 && (reasoningBlocks.length > 0 || fallbackBlocks.length > 0)) {
+      const state = {
+        reasoning: reasoningBlocks,
+        model: servingModel,
+        requestedModel: this.model
+      };
+      if (fallbackBlocks.length > 0)
+        state.fallbacks = fallbackBlocks;
+      toolCalls[0].providerMetadata = Object.assign(Object.assign({}, toolCalls[0].providerMetadata), { [ANTHROPIC_PROVIDER_KEY]: state });
+    }
     if (response.stop_reason === "max_tokens" && toolCalls.length > 0) {
       throw new ResponseTruncatedError(this.model, this.maxTokens, outputTokens, toolCalls.map((tc) => tc.name));
     }
@@ -1883,6 +2171,7 @@ ${att.content}` });
       base.cacheWriteTokens = cacheWriteTokens;
     if (cost != null)
       base.cost = cost;
+    base.model = servingModel;
     if (response.stop_reason === "max_tokens") {
       base.responseMeta = { finishReason: "max_tokens" };
     }
@@ -2184,43 +2473,25 @@ function assertSupportedGeminiModel(model) {
     throw new Error(`GeminiTransport: unsupported model "${model}". Use one of: ${SUPPORTED_GEMINI_MODEL_IDS.join(", ")}.`);
   }
 }
-var GEMINI_LONG_CONTEXT_THRESHOLD = 2e5;
-var GEMINI_CACHED_INPUT_MULTIPLIER = 0.1;
-var GEMINI_PRICING = {
-  "gemini-2.5-flash-lite": {
-    kind: "flat",
-    rate: { promptPerMillion: 0.1, candidatePerMillion: 0.4 }
-  },
-  "gemini-2.5-flash": { kind: "flat", rate: { promptPerMillion: 0.3, candidatePerMillion: 2.5 } },
-  "gemini-2.5-pro": {
-    kind: "tiered",
-    standard: { promptPerMillion: 1.25, candidatePerMillion: 10 },
-    longContext: { promptPerMillion: 2.5, candidatePerMillion: 15 }
-  },
-  "gemini-3.1-flash-lite": {
-    kind: "flat",
-    rate: { promptPerMillion: 0.25, candidatePerMillion: 1.5 }
-  },
-  "gemini-3.5-flash": { kind: "flat", rate: { promptPerMillion: 1.5, candidatePerMillion: 9 } },
-  "gemini-3.1-pro-preview": {
-    kind: "tiered",
-    standard: { promptPerMillion: 2, candidatePerMillion: 12 },
-    longContext: { promptPerMillion: 4, candidatePerMillion: 18 }
-  }
-};
-function estimatedGeminiPaidRatesUsdPerMillion(model, promptTokens) {
-  const pricing = GEMINI_PRICING[model];
-  if (pricing.kind === "flat") {
-    return pricing.rate;
-  }
-  return promptTokens > GEMINI_LONG_CONTEXT_THRESHOLD ? pricing.longContext : pricing.standard;
-}
 var GEMINI_MODEL_WARNINGS = {
   "gemini-2.5-flash": "GeminiTransport: using gemini-2.5-flash \u2014 higher cost than flash-lite; use for harder reasoning or agent tasks.",
   "gemini-2.5-pro": "GeminiTransport: using gemini-2.5-pro \u2014 significantly higher, prompt-size-tiered cost; reserve for tasks where flash reliability is insufficient.",
   "gemini-3.5-flash": "GeminiTransport: using gemini-3.5-flash \u2014 frontier model, materially higher cost than flash-lite; use for harder reasoning or agent tasks.",
   "gemini-3.1-pro-preview": "GeminiTransport: using gemini-3.1-pro-preview \u2014 PREVIEW model (no stability guarantee, may be withdrawn) with significantly higher, prompt-size-tiered cost; reserve for tasks where flash reliability is insufficient."
 };
+var GEMINI_THINKING_DISABLEABLE = [
+  "gemini-2.5-flash",
+  "gemini-2.5-flash-lite"
+];
+function geminiThinkingConfig(model, policy) {
+  if (policy === "off" && GEMINI_THINKING_DISABLEABLE.includes(model)) {
+    return { includeThoughts: false, thinkingBudget: 0 };
+  }
+  if (policy === "auto" && GEMINI_THINKING_DISABLEABLE.includes(model)) {
+    return { includeThoughts: true, thinkingBudget: -1 };
+  }
+  return { includeThoughts: true };
+}
 var SKIP_SIGNATURE = "skip_thought_signature_validator";
 var GEMINI_PROVIDER_KEY = "gemini";
 var MalformedFunctionCallError = class extends Error {
@@ -2231,10 +2502,28 @@ var MalformedFunctionCallError = class extends Error {
   }
 };
 var GeminiTransport = class _GeminiTransport {
+  /**
+   * Warn once when a requested policy is silently clamped. Turning thinking off is a *cost*
+   * decision, so a caller who asked for it and kept paying for reasoning tokens needs to hear
+   * about it — but only once, not per turn.
+   *
+   * Only `'off'` can actually be denied. `'auto'` is already what an omitted budget produces on
+   * every model here — dynamic thinking is the documented default — so warning that it was
+   * "ignored" would be false, and latching on it would spend the one warning the genuinely
+   * unhonourable `'off'` needs.
+   */
+  warnIfThinkingUnclampable(policy) {
+    if (policy !== "off" || GEMINI_THINKING_DISABLEABLE.includes(this.model) || this.warnedThinkingClamped) {
+      return;
+    }
+    this.warnedThinkingClamped = true;
+    logger.warn(`GeminiTransport: thinkingPolicy 'off' ignored \u2014 ${this.model} runs its default thinking posture and takes no budget we can safely set. Reasoning tokens are still billed at the candidate rate; use a flash tier if you need them gone.`);
+  }
   constructor(config = {}) {
     var _a, _b, _c;
     this.lifetimeCostUsd = 0;
     this.lifetimeSavingsUsd = 0;
+    this.warnedThinkingClamped = false;
     const model = (_a = config.model) !== null && _a !== void 0 ? _a : DEFAULT_MODEL2;
     assertSupportedGeminiModel(model);
     this.model = model;
@@ -2301,7 +2590,8 @@ var GeminiTransport = class _GeminiTransport {
       ] : void 0;
       const systemInstruction = (options === null || options === void 0 ? void 0 : options.systemPrompt) ? { role: "system", parts: [{ text: options.systemPrompt }] } : void 0;
       const toolConfig = tools ? toGeminiToolConfig(options === null || options === void 0 ? void 0 : options.toolChoice) : void 0;
-      const generationConfig = { thinkingConfig: { includeThoughts: true } };
+      this.warnIfThinkingUnclampable(options === null || options === void 0 ? void 0 : options.thinkingPolicy);
+      const generationConfig = { thinkingConfig: geminiThinkingConfig(this.model, options === null || options === void 0 ? void 0 : options.thinkingPolicy) };
       if ((options === null || options === void 0 ? void 0 : options.temperature) != null) {
         generationConfig.temperature = scaleTemperature(options.temperature, {
           defaultTemp: GEMINI_DEFAULT_TEMPERATURE,
@@ -2328,25 +2618,23 @@ var GeminiTransport = class _GeminiTransport {
    * message.
    */
   logTokenUsage(promptTokens, candidateTokens, thoughtTokens, cachedTokens) {
-    const { promptPerMillion, candidatePerMillion } = estimatedGeminiPaidRatesUsdPerMillion(this.model, promptTokens);
-    const m = _GeminiTransport.TOKENS_PER_MILLION;
-    const uncachedPromptTokens = Math.max(0, promptTokens - cachedTokens);
-    const promptCost = uncachedPromptTokens / m * promptPerMillion;
-    const cacheReadCost = cachedTokens / m * promptPerMillion * GEMINI_CACHED_INPUT_MULTIPLIER;
-    const candidateCost = (candidateTokens + thoughtTokens) / m * candidatePerMillion;
-    const totalCost = promptCost + cacheReadCost + candidateCost;
-    this.lifetimeCostUsd += totalCost;
-    const saved = cachedTokens / m * promptPerMillion - cacheReadCost;
-    this.lifetimeSavingsUsd += saved;
+    const { costUsd, savedUsd, breakdown } = geminiTokenCost(this.model, {
+      promptTokens,
+      candidateTokens,
+      thoughtTokens,
+      cachedTokens
+    });
+    this.lifetimeCostUsd += costUsd;
+    this.lifetimeSavingsUsd += savedUsd;
     const dp = _GeminiTransport.COST_DECIMAL_PLACES;
     console.log(`--- Gemini Token Usage (${this.model}) ---`);
-    console.log(`Prompt Tokens:    ${promptTokens} (${cachedTokens} cached) ($${promptCost.toFixed(dp)} + $${cacheReadCost.toFixed(dp)})`);
-    console.log(`Candidate Tokens: ${candidateTokens} (+${thoughtTokens} thinking) ($${candidateCost.toFixed(dp)})`);
-    console.log(`Total Cost:       $${totalCost.toFixed(dp)}`);
-    console.log(`Cache Saved:      $${saved.toFixed(dp)} (lifetime $${this.lifetimeSavingsUsd.toFixed(dp)})`);
+    console.log(`Prompt Tokens:    ${promptTokens} (${cachedTokens} cached) ($${breakdown.promptUsd.toFixed(dp)} + $${breakdown.cacheReadUsd.toFixed(dp)})`);
+    console.log(`Candidate Tokens: ${candidateTokens} (+${thoughtTokens} thinking) ($${breakdown.candidateUsd.toFixed(dp)})`);
+    console.log(`Total Cost:       $${costUsd.toFixed(dp)}`);
+    console.log(`Cache Saved:      $${savedUsd.toFixed(dp)} (lifetime $${this.lifetimeSavingsUsd.toFixed(dp)})`);
     console.log(`Lifetime Cost:    $${this.lifetimeCostUsd.toFixed(dp)}`);
     console.log("--------------------------");
-    return totalCost;
+    return costUsd;
   }
   toGeminiContents(history, userMessage, attachments) {
     var _a, _b, _c;
@@ -3317,6 +3605,18 @@ function emptyUsage() {
     outputTokens: 0
   };
 }
+function totalTokens(usage) {
+  return usage.uncachedInputTokens + usage.cacheReadTokens + usage.cacheWriteTokens + usage.outputTokens;
+}
+function addUsage(a, b) {
+  return {
+    costUsd: a.costUsd + b.costUsd,
+    uncachedInputTokens: a.uncachedInputTokens + b.uncachedInputTokens,
+    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens,
+    cacheWriteTokens: a.cacheWriteTokens + b.cacheWriteTokens,
+    outputTokens: a.outputTokens + b.outputTokens
+  };
+}
 function sumUsage(messages) {
   const total = emptyUsage();
   accumulate(messages, total);
@@ -3805,6 +4105,7 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     this.activeTemperatureInput = config.temperature;
     this.activeToolChoiceInput = config.toolChoice;
     this.activeCachePolicyInput = config.cachePolicy;
+    this.activeThinkingPolicyInput = config.thinkingPolicy;
     this.activeTailContextInput = config.tailContext;
     this.activeResponseSchemaInput = config.responseSchema;
     this.activeFallbacks = config.fallbacks;
@@ -4459,16 +4760,27 @@ Output format (strict):
    *   `condenseWhen` can register against the right call (it stamps the clocks
    *   straight off the driver). Absent for dispatch paths with no addressable tool
    *   call (e.g. the fold-close handler), where `condenseWhen` is a no-op.
-   * @param traceCapture - Optional per-invocation slot. When provided, the trace
-   *   from any sub-agent call is written here rather than to shared instance state,
-   *   so parallel tool calls each capture their own trace independently.
+   * @param traceCapture - Optional per-tool-call accumulator. When provided, every
+   *   sub-agent call's trace is **appended** here rather than written to shared
+   *   instance state, so parallel tool calls each capture their own traces
+   *   independently.
+   *
+   *   Deliberately a list of traces, not one slot. A single handler may call
+   *   `requestSubAgent` more than once — a code-driven scheduler dispatching a
+   *   dependency graph, a retry of a timed-out child, any fan-out helper — and a
+   *   single slot kept only the last, so every other child ran, was billed by the
+   *   provider, and then vanished from history. The loss was silent in the worst
+   *   way: `sumUsage` and `usageRows` both recurse into the trace, so they summed a
+   *   truncated input and still agreed with each other. Measured at 1 of 7 traces
+   *   kept on a seven-way fan-out, reporting ~2.3x under the real cost, with the
+   *   error growing as the fan-out widens.
    */
   buildHandlerContext(activeToolCallId, traceCapture) {
     return {
       requestInteraction: (componentName, data, options) => this.requestInteraction(componentName, data, options),
       ...this.subAgentsMap.size > 0 && {
         requestSubAgent: (name, options) => this.invokeSubAgent(name, options).then(({ outcome, trace }) => {
-          if (traceCapture) traceCapture.trace = trace;
+          if (traceCapture && trace) traceCapture.traces.push(trace);
           return outcome;
         })
       },
@@ -4842,6 +5154,8 @@ Output format (strict):
     let emptyResponseAttempts = 0;
     let setupTransportAttempts = 0;
     let firstLlmCall = !!currentInput;
+    let pinnedThinkingPolicy;
+    let thinkingPolicyPinned = false;
     while (iterations < this.maxToolIterations) {
       iterations += 1;
       this.modelCallSeq += 1;
@@ -4941,7 +5255,8 @@ Output format (strict):
         resolvedToolChoice,
         resolvedCachePolicy,
         resolvedTailContext,
-        resolvedResponseSchema
+        resolvedResponseSchema,
+        firstResolvedThinkingPolicy
       ] = (
         // oxlint-disable-next-line no-await-in-loop
         await Promise.all([
@@ -4949,9 +5264,19 @@ Output format (strict):
           this.resolveTurnInput(this.activeToolChoiceInput, promptCtx),
           this.resolveTurnInput(this.activeCachePolicyInput, promptCtx),
           this.resolveTurnInput(this.activeTailContextInput, promptCtx),
-          this.resolveTurnInput(this.activeResponseSchemaInput, promptCtx)
+          this.resolveTurnInput(this.activeResponseSchemaInput, promptCtx),
+          // Only consulted on the first iteration (see `pinnedThinkingPolicy`); resolved
+          // alongside the others so a resolver still sees the same turn context.
+          thinkingPolicyPinned ? Promise.resolve(void 0) : this.resolveTurnInput(
+            this.activeThinkingPolicyInput,
+            promptCtx
+          )
         ])
       );
+      if (!thinkingPolicyPinned) {
+        pinnedThinkingPolicy = firstResolvedThinkingPolicy;
+        thinkingPolicyPinned = true;
+      }
       const systemPrompt = resolvedSystemPrompt || void 0;
       const tailBody = [resolvedTailContext, frameworkSystemSuffix].map((part) => (part ?? "").trim()).filter((part) => part.length > 0).join("\n\n");
       const tailContext = tailBody ? `<system-reminder>
@@ -4978,6 +5303,12 @@ ${tailBody}
         // Prompt-cache policy for this turn (Anthropic places breakpoints per scope; Gemini
         // caches implicitly regardless). Undefined → no caching requested.
         cachePolicy: resolvedCachePolicy,
+        // Extended-thinking posture, pinned for the whole tool loop (one assistant turn) rather
+        // than re-resolved per iteration — see `pinnedThinkingPolicy`. Undefined — unset, or the
+        // resolver's answer for this turn — is NOT "off": it leaves the model on its own default,
+        // so agents that never set this are priced exactly as before. Transports clamp models
+        // that can't honour it.
+        thinkingPolicy: pinnedThinkingPolicy,
         // Framed volatile context injected at the message tail (never stored). Undefined → none.
         tailContext,
         // Structured-output schema for this turn (agent/state-resolved). When set, the transport
@@ -5098,7 +5429,9 @@ ${tailBody}
         }
         throw e;
       }
-      if (this.lastResolvedModel !== void 0) response.model = this.lastResolvedModel;
+      if (response.model === void 0 && this.lastResolvedModel !== void 0) {
+        response.model = this.lastResolvedModel;
+      }
       if (this.lastResolvedProvider !== void 0) response.provider = this.lastResolvedProvider;
       if (this.lastResolvedProviderName !== void 0) {
         response.providerName = this.lastResolvedProviderName;
@@ -5306,14 +5639,18 @@ ${tailBody}
               }
               return;
             }
+            const traceCapture = { traces: [] };
+            const capturedTrace = () => traceCapture.traces.length ? traceCapture.traces.flat() : void 0;
             try {
-              const traceCapture = {};
               const result = await handler(tc.args, this.buildHandlerContext(tc.id, traceCapture));
               const content = typeof result === "string" ? result : JSON.stringify(result);
               executedById.set(tc.id, {
                 toolCallId: tc.id,
                 content,
-                subAgentTrace: traceCapture.trace
+                // Concatenated when a handler invoked several children, so none is lost.
+                // Stays `undefined` when nothing was captured — readers key off presence,
+                // and an empty array is a different claim from "no sub-agent ran".
+                subAgentTrace: capturedTrace()
               });
               anyRealToolExecuted = true;
             } catch (e) {
@@ -5328,7 +5665,10 @@ ${tailBody}
                 // Structured recovery hint so the model retries or routes around a tool
                 // failure instead of apologising and giving up.
                 content: `Tool error: ${e.message}
-RECOVERY: this tool failed once \u2014 you may retry it, or take a different valid action to make progress. Do NOT abandon the task, ask the user to rephrase, or claim you cannot make changes. If a planning tool failed, retry it or proceed with the information you already have.`
+RECOVERY: this tool failed once \u2014 you may retry it, or take a different valid action to make progress. Do NOT abandon the task, ask the user to rephrase, or claim you cannot make changes. If a planning tool failed, retry it or proceed with the information you already have.`,
+                // Children that completed before the throw were still billed — keep
+                // their traces so the run's cost stays whole.
+                subAgentTrace: capturedTrace()
               });
               anyRealToolExecuted = true;
             }
@@ -6120,6 +6460,10 @@ function defineStatefulAgent(opts) {
     }
     return opts.cachePolicy({ ...ctx, state });
   } : opts.cachePolicy;
+  const wrappedThinkingPolicy = typeof opts.thinkingPolicy === "function" ? async (ctx) => {
+    if (!state) return void 0;
+    return opts.thinkingPolicy({ ...ctx, state });
+  } : opts.thinkingPolicy;
   const wrappedTailContext = typeof opts.tailContext === "function" ? async (ctx) => {
     if (!state) {
       throw new Error(`Stateful agent "${opts.name}" tailContext called before init`);
@@ -6158,6 +6502,7 @@ function defineStatefulAgent(opts) {
     temperature: wrappedTemperature,
     toolChoice: wrappedToolChoice,
     cachePolicy: wrappedCachePolicy,
+    thinkingPolicy: wrappedThinkingPolicy,
     tailContext: wrappedTailContext,
     onUnresolvedTool: wrappedOnUnresolvedTool,
     resumable: wrappedResumable,
@@ -6219,6 +6564,69 @@ var strictFallbackAgent = {
   systemPrompt: `You are a concise assistant. The user's request is outside your scope. Respond with a single short sentence stating what you can assist with. Do not elaborate. The available specialists are: {{agents}}.`
 };
 
+// src/utils/usage-rows.ts
+function hasUsage(m) {
+  return m.cost != null || m.externalCostUsd != null || m.inputTokens != null || m.outputTokens != null || m.cacheReadTokens != null || m.cacheWriteTokens != null;
+}
+function usageRows(messages) {
+  return collectRows(messages, 0, void 0);
+}
+function bucketsOf(usage) {
+  return {
+    uncachedInputTokens: usage.uncachedInputTokens,
+    cacheReadTokens: usage.cacheReadTokens,
+    cacheWriteTokens: usage.cacheWriteTokens,
+    outputTokens: usage.outputTokens
+  };
+}
+function collectRows(messages, depth, subAgentOf) {
+  const rows = [];
+  for (const m of messages) {
+    if (hasUsage(m)) {
+      const cacheReadTokens = m.cacheReadTokens ?? 0;
+      const cacheWriteTokens = m.cacheWriteTokens ?? 0;
+      rows.push({
+        source: "request",
+        model: m.model,
+        // The driver stamps `ChatMessage.provider` from the resolved provider's own
+        // status, so it is AUTHORITATIVE and covers vendors the model allowlists do
+        // not — a server-proxied `gpt-5` turn is `provider: 'openai'` on the message
+        // and unknown to `vendorOfModel`. Prefer it; fall back to resolving the model
+        // id only for messages persisted before the field existed. Still left
+        // undefined when neither knows, rather than guessed at.
+        provider: m.provider ?? (m.model ? vendorOfModel(m.model) : void 0),
+        ...m.cost != null && { costUsd: m.cost },
+        ...m.externalCostUsd != null && { externalCostUsd: m.externalCostUsd },
+        // Uncached input is the REMAINDER, matching `sumUsage`: `inputTokens` is the
+        // whole prompt and the cache fields break it down. Clamped for the same
+        // reason — hand-edited history must not drive a total negative.
+        uncachedInputTokens: Math.max(0, (m.inputTokens ?? 0) - cacheReadTokens - cacheWriteTokens),
+        cacheReadTokens,
+        cacheWriteTokens,
+        outputTokens: m.outputTokens ?? 0,
+        ...m.agentName != null && { agentName: m.agentName },
+        subAgentDepth: depth,
+        ...subAgentOf != null && { subAgentOf }
+      });
+    }
+    const rolled = m.compaction?.rolledUpUsage;
+    if (rolled) {
+      rows.push({
+        source: "compaction",
+        ...rolled.costUsd != null && { costUsd: rolled.costUsd },
+        ...bucketsOf(rolled),
+        ...m.agentName != null && { agentName: m.agentName },
+        subAgentDepth: depth,
+        ...subAgentOf != null && { subAgentOf }
+      });
+    }
+    for (const tc of m.toolCalls ?? []) {
+      if (tc.subAgentTrace) rows.push(...collectRows(tc.subAgentTrace, depth + 1, tc.id));
+    }
+  }
+  return rows;
+}
+
 // src/utils/flatten-sub-agent-messages.ts
 function flattenSubAgentMessages(messages, prefix = "", depth = 0, subAgentOf) {
   return messages.flatMap((m) => {
@@ -6300,10 +6708,15 @@ function assembleDebugLog(entries, readme) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ANTHROPIC_CACHE_READ_MULTIPLIER,
+  ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER,
+  ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER,
   AgenticActivityBus,
   AnthropicProvider,
   AnthropicTransport,
   ChatDriver,
+  GEMINI_CACHED_INPUT_MULTIPLIER,
+  GEMINI_LONG_CONTEXT_THRESHOLD,
   GeminiProvider,
   GeminiTransport,
   MutableAIProviderRegistry,
@@ -6312,16 +6725,26 @@ function assembleDebugLog(entries, readme) {
   REQUEST_CONTINUATION_TOOL,
   SUPPORTED_ANTHROPIC_MODEL_IDS,
   SUPPORTED_GEMINI_MODEL_IDS,
+  addUsage,
   agenticActivityBus,
+  anthropicRatesFor,
+  anthropicTokenCost,
   assembleDebugLog,
   buildTimelineEntries,
   clearSession,
   defineAgent,
   defineStatefulAgent,
+  emptyUsage,
   friendlyFallbackAgent,
+  geminiRatesFor,
+  geminiTokenCost,
   getMetaEvents,
   isObservableAIProviderRegistry,
   restoreMachine,
-  strictFallbackAgent
+  strictFallbackAgent,
+  sumUsage,
+  totalTokens,
+  usageRows,
+  vendorOfModel
 });
 //# sourceMappingURL=chat-driver.cjs.map