@axlsdk/axl 0.20.0 → 0.20.1

package/dist/index.js

@@ -666,6 +666,42 @@ var RateLimiter = class {
   }
 };
 
+// src/providers/builtin-table-pricing.ts
+var policies = /* @__PURE__ */ new WeakMap();
+function attachBuiltinTablePricingPolicy(profile, policy) {
+  if (profile.pricing.kind !== "table") {
+    throw new Error("Built-in table pricing policy requires table pricing.");
+  }
+  policies.set(profile.pricing.table, policy);
+}
+function hasFunctionToolsOnly(value) {
+  return value === void 0 || Array.isArray(value) && value.every(
+    (tool2) => tool2 !== null && typeof tool2 === "object" && tool2.type === "function"
+  );
+}
+function hasValidRequiredCacheSplit(context) {
+  const usage = context.response?.usage;
+  const hit = usage?.prompt_cache_hit_tokens;
+  const miss = usage?.prompt_cache_miss_tokens;
+  return typeof hit === "number" && typeof miss === "number" && Number.isSafeInteger(hit) && Number.isSafeInteger(miss) && hit >= 0 && miss >= 0 && hit + miss === usage?.prompt_tokens;
+}
+function isBuiltinTablePricingEligible(profile, context) {
+  const policy = profile.pricing.kind === "table" ? policies.get(profile.pricing.table) : void 0;
+  if (!policy) return true;
+  if (policy.canonicalBaseUrl && context.baseUrl !== policy.canonicalBaseUrl) return false;
+  if (policy.requireCacheSplit && !hasValidRequiredCacheSplit(context)) return false;
+  if (policy.functionToolsOnly && !hasFunctionToolsOnly(context.request?.tools)) return false;
+  if (policy.chargedRequestModifiers?.some((modifier) => context.request?.[modifier] !== void 0)) {
+    return false;
+  }
+  if (!policy.supportedServiceTiers) return true;
+  const requestTier = context.request?.service_tier ?? context.request?.serviceTier;
+  const responseTier = context.response?.service_tier ?? context.response?.serviceTier;
+  const effectiveTier = responseTier ?? requestTier;
+  if (effectiveTier === void 0) return true;
+  return typeof effectiveTier === "string" && policy.supportedServiceTiers.includes(effectiveTier);
+}
+
 // src/providers/openai-compatible.ts
 function resolvePerModel(value, model, fallback) {
   if (value === void 0) return fallback;
@@ -680,9 +716,13 @@ function sortedKeys(table) {
   }
   return keys;
 }
-function priceFromTable(table, model, promptTokens, completionTokens, cachedTokens) {
+function priceFromTable(table, model, promptTokens, completionTokens, cachedTokens, match = "prefix") {
+  const cached = cachedTokens ?? 0;
+  if (!Number.isSafeInteger(promptTokens) || !Number.isSafeInteger(completionTokens) || !Number.isSafeInteger(cached) || promptTokens < 0 || completionTokens < 0 || cached < 0 || cached > promptTokens) {
+    return void 0;
+  }
   let pricing = table[model];
-  if (!pricing) {
+  if (!pricing && match === "prefix") {
     for (const key of sortedKeys(table)) {
       if (model.startsWith(key)) {
         pricing = table[key];
@@ -692,7 +732,6 @@ function priceFromTable(table, model, promptTokens, completionTokens, cachedToke
   }
   if (!pricing) return void 0;
   const [inputRate, outputRate, cacheMultiplier] = pricing;
-  const cached = cachedTokens ?? 0;
   const inputCost = (promptTokens - cached) * inputRate + cached * inputRate * cacheMultiplier;
   return inputCost + completionTokens * outputRate;
 }
@@ -853,7 +892,7 @@ var OpenAICompatibleProvider = class {
       });
     }
     const json = await res.json();
-    return this.parseResponse(json, options.model);
+    return this.parseResponse(json, this.requestModel(body, options.model), body);
   }
   async *stream(messages, options) {
     const headers = this.buildHeaders(await this.resolveKey());
@@ -881,7 +920,7 @@ var OpenAICompatibleProvider = class {
     if (!res.body) {
       throw new Error(`${this.profile.label ?? this.profile.name} stream response has no body`);
     }
-    yield* this.parseSSEStream(res.body, options.model);
+    yield* this.parseSSEStream(res.body, this.requestModel(body, options.model), body);
   }
   // ---------------------------------------------------------------------------
   // Request building
@@ -902,12 +941,13 @@ var OpenAICompatibleProvider = class {
   buildRequestBody(messages, options, stream) {
     const profile = this.profile;
     const resolved = resolveThinkingOptions(options);
+    const effectiveModel = typeof options.providerOptions?.model === "string" ? options.providerOptions.model : options.model;
     const body = {
-      model: options.model,
-      messages: messages.map((m) => this.formatMessage(m, options.model)),
+      model: effectiveModel,
+      messages: messages.map((m) => this.formatMessage(m, effectiveModel)),
       stream
     };
-    const emitResult = profile.reasoning.emit(body, resolved, options.model) ?? {};
+    const emitResult = profile.reasoning.emit(body, resolved, effectiveModel) ?? {};
     const stripTemperature = emitResult.stripTemperature ?? false;
     if (options.temperature !== void 0 && !stripTemperature) {
       body.temperature = options.temperature;
@@ -918,7 +958,7 @@ var OpenAICompatibleProvider = class {
     if (options.stop) body.stop = options.stop;
     if (options.tools && options.tools.length > 0) {
       body.tools = options.tools;
-      if (resolvePerModel(profile.parallelToolCalls, options.model, false)) {
+      if (resolvePerModel(profile.parallelToolCalls, effectiveModel, false)) {
         body.parallel_tool_calls = true;
       }
     }
@@ -926,7 +966,7 @@ var OpenAICompatibleProvider = class {
     if (options.responseFormat) {
       const supportsSchema = resolvePerModel(
         profile.capabilities?.supportsJsonSchema,
-        options.model,
+        effectiveModel,
         true
       );
       body.response_format = options.responseFormat.type === "json_schema" && !supportsSchema ? { type: "json_object" } : options.responseFormat;
@@ -937,7 +977,7 @@ var OpenAICompatibleProvider = class {
     if (profile.requestDefaults) Object.assign(body, profile.requestDefaults);
     const userKeys = options.providerOptions ? Object.keys(options.providerOptions) : [];
     if (options.providerOptions) Object.assign(body, options.providerOptions);
-    const forbidden = resolvePerModel(profile.capabilities?.forbiddenParams, options.model, []);
+    const forbidden = resolvePerModel(profile.capabilities?.forbiddenParams, effectiveModel, []);
     for (const key of forbidden) {
       if (!userKeys.includes(key)) delete body[key];
     }
@@ -972,6 +1012,9 @@ var OpenAICompatibleProvider = class {
     }
     return `${label} API error (${status}): ${body}`;
   }
+  requestModel(body, fallback) {
+    return typeof body.model === "string" ? body.model : fallback;
+  }
   toUsage(raw) {
     if (!raw) return void 0;
     return {
@@ -979,10 +1022,27 @@ var OpenAICompatibleProvider = class {
       completion_tokens: raw.completion_tokens,
       total_tokens: raw.total_tokens,
       reasoning_tokens: raw.completion_tokens_details?.reasoning_tokens,
-      cached_tokens: raw.prompt_tokens_details?.cached_tokens
+      // DeepSeek reports the cache split at the top level rather than under
+      // prompt_tokens_details. Preserve the normalized hit count for the
+      // generic table estimator; its split is validated before pricing.
+      cached_tokens: raw.prompt_cache_hit_tokens ?? raw.prompt_tokens_details?.cached_tokens,
+      cache_write_tokens: raw.prompt_tokens_details?.cache_write_tokens
     };
   }
-  computeCost(model, usage, reportedCost) {
+  reportedCost(raw) {
+    if (!raw) return void 0;
+    if (this.profile.name === "xai") {
+      const ticks = raw.cost_in_usd_ticks;
+      return typeof ticks === "number" && Number.isSafeInteger(ticks) && ticks >= 0 ? ticks / 1e10 : void 0;
+    }
+    return typeof raw.cost === "number" && Number.isFinite(raw.cost) && raw.cost >= 0 ? raw.cost : void 0;
+  }
+  /**
+   * The generic profile path stays flat and public. Native subclasses may
+   * override this protected seam to use a provider-internal estimator without
+   * widening `PricingSource` or `ProviderProfile`.
+   */
+  computeCost(model, usage, reportedCost, context) {
     const p = this.profile.pricing;
     if (p.kind === "zero") return 0;
     if (!usage) return void 0;
@@ -990,14 +1050,22 @@ var OpenAICompatibleProvider = class {
       case "unknown":
         return void 0;
       case "from-response":
-        return typeof reportedCost === "number" && Number.isFinite(reportedCost) ? reportedCost : void 0;
+        return typeof reportedCost === "number" && Number.isFinite(reportedCost) && reportedCost >= 0 ? reportedCost : void 0;
       case "table": {
+        if (!isBuiltinTablePricingEligible(this.profile, {
+          baseUrl: this.baseUrl,
+          request: context?.request,
+          response: context?.response
+        })) {
+          return void 0;
+        }
         const c = priceFromTable(
           p.table,
           model,
           usage.prompt_tokens,
           usage.completion_tokens,
-          usage.cached_tokens
+          usage.cached_tokens,
+          p.match
         );
         return c !== void 0 && Number.isFinite(c) ? c : void 0;
       }
@@ -1007,7 +1075,7 @@ var OpenAICompatibleProvider = class {
       }
     }
   }
-  parseResponse(json, model) {
+  parseResponse(json, model, request) {
     const message = json.choices?.[0]?.message ?? {};
     let content = normalizeMessageContent(message.content);
     let thinking;
@@ -1053,7 +1121,10 @@ var OpenAICompatibleProvider = class {
       }
     }
     const usage = this.toUsage(json.usage);
-    const cost = this.computeCost(model, usage, json.usage?.cost);
+    const cost = this.computeCost(json.model ?? model, usage, this.reportedCost(json.usage), {
+      request,
+      response: json
+    });
     return {
       content,
       thinking_content: thinking || void 0,
@@ -1076,11 +1147,12 @@ var OpenAICompatibleProvider = class {
   // ---------------------------------------------------------------------------
   // SSE streaming
   // ---------------------------------------------------------------------------
-  async *parseSSEStream(body, model) {
+  async *parseSSEStream(body, model, request) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
     let usageData;
+    let pricingResponse;
     const capture = this.profile.reasoning.capture;
     const thinkScanner = capture === "think_tags" ? new ThinkTagScanner() : void 0;
     let reasoningText = "";
@@ -1121,7 +1193,15 @@ var OpenAICompatibleProvider = class {
       return {
         type: "done",
         usage,
-        cost: this.computeCost(model, usage, usageData?.cost),
+        cost: this.computeCost(
+          pricingResponse?.model ?? model,
+          usage,
+          this.reportedCost(usageData),
+          {
+            request,
+            response: pricingResponse
+          }
+        ),
         providerMetadata
       };
     };
@@ -1162,8 +1242,12 @@ var OpenAICompatibleProvider = class {
               body: JSON.stringify(parsed.error)
             });
           }
+          if (parsed.model !== void 0 || parsed.service_tier !== void 0 || parsed.serviceTier !== void 0) {
+            pricingResponse = { ...pricingResponse, ...parsed };
+          }
           if (parsed.usage) {
             usageData = parsed.usage;
+            pricingResponse = { ...pricingResponse, ...parsed };
             if (!parsed.choices || parsed.choices.length === 0) continue;
           }
           const delta = parsed.choices?.[0]?.delta;
@@ -1237,38 +1321,328 @@ var OpenAICompatibleProvider = class {
 
 // src/providers/openai.ts
 var OPENAI_PRICING = {
-  // gpt-4o era — cache reads at 50% of input rate
+  // Flat, exact Standard rows only. Context-tiered and cache-write-priced
+  // models intentionally stay out of this compatibility view.
   "gpt-4o": [25e-7, 1e-5, 0.5],
   "gpt-4o-mini": [15e-8, 6e-7, 0.5],
-  "gpt-4-turbo": [1e-5, 3e-5, 0.5],
-  "gpt-4": [3e-5, 6e-5, 0.5],
-  "gpt-3.5-turbo": [5e-7, 15e-7, 0.5],
   o1: [15e-6, 6e-5, 0.5],
-  "o1-mini": [3e-6, 12e-6, 0.5],
-  "o1-pro": [15e-5, 6e-4, 0.5],
-  // gpt-4.1 / o3 / o4 era — cache reads at 25% of input rate
   "gpt-4.1": [2e-6, 8e-6, 0.25],
   "gpt-4.1-mini": [4e-7, 16e-7, 0.25],
   "gpt-4.1-nano": [1e-7, 4e-7, 0.25],
-  o3: [1e-5, 4e-5, 0.25],
+  o3: [2e-6, 8e-6, 0.25],
   "o3-mini": [11e-7, 44e-7, 0.25],
-  "o3-pro": [2e-5, 8e-5, 0.25],
   "o4-mini": [11e-7, 44e-7, 0.25],
-  // gpt-5 era — cache reads at 10% of input rate
   "gpt-5": [125e-8, 1e-5, 0.1],
   "gpt-5-mini": [25e-8, 2e-6, 0.1],
   "gpt-5-nano": [5e-8, 4e-7, 0.1],
   "gpt-5.1": [125e-8, 1e-5, 0.1],
-  "gpt-5.2": [175e-8, 14e-6, 0.1],
-  "gpt-5.3": [175e-8, 14e-6, 0.1],
-  "gpt-5.4": [25e-7, 15e-6, 0.1],
-  "gpt-5.4-pro": [3e-5, 18e-5, 0.1],
-  // gpt-5.5 era (flagship released 2026-04) — cache reads at 10% of input rate
-  "gpt-5.5": [5e-6, 3e-5, 0.1],
-  "gpt-5.5-pro": [3e-5, 18e-5, 0.1]
+  "gpt-5.2": [175e-8, 14e-6, 0.1]
 };
+var M = 1e6;
+var LONG_CONTEXT_BOUNDARY = 272e3;
+var withLongContext = (short) => ({
+  input: short.input * 2,
+  cachedInput: short.cachedInput === void 0 ? void 0 : short.cachedInput * 2,
+  cacheWrite: short.cacheWrite === void 0 ? void 0 : short.cacheWrite * 2,
+  output: short.output * 1.5
+});
+var DIRECT_OPENAI_CATALOG = [
+  {
+    aliases: ["gpt-5.6", "gpt-5.6-sol"],
+    snapshotBase: "gpt-5.6-sol",
+    short: { input: 5 / M, cachedInput: 0.5 / M, cacheWrite: 6.25 / M, output: 30 / M },
+    long: withLongContext({
+      input: 5 / M,
+      cachedInput: 0.5 / M,
+      cacheWrite: 6.25 / M,
+      output: 30 / M
+    }),
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
+  {
+    aliases: ["gpt-5.6-terra"],
+    snapshotBase: "gpt-5.6-terra",
+    short: { input: 2 / M, cachedInput: 0.2 / M, cacheWrite: 2.5 / M, output: 12 / M },
+    long: withLongContext({
+      input: 2 / M,
+      cachedInput: 0.2 / M,
+      cacheWrite: 2.5 / M,
+      output: 12 / M
+    }),
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
+  {
+    aliases: ["gpt-5.6-luna"],
+    snapshotBase: "gpt-5.6-luna",
+    short: { input: 0.2 / M, cachedInput: 0.02 / M, cacheWrite: 0.25 / M, output: 1.2 / M },
+    long: withLongContext({
+      input: 0.2 / M,
+      cachedInput: 0.02 / M,
+      cacheWrite: 0.25 / M,
+      output: 1.2 / M
+    }),
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
+  // Existing direct models retain literal current Standard rows. These flat
+  // rows keep native pricing aligned with the compatibility wrapper while the
+  // private estimator still validates categories and billing mode strictly.
+  {
+    aliases: ["gpt-4o", "gpt-4o-2024-08-06", "gpt-4o-2024-11-20"],
+    snapshotBase: "gpt-4o",
+    short: { input: 2.5 / M, cachedInput: 1.25 / M, output: 10 / M }
+  },
+  {
+    aliases: ["gpt-4o-mini", "gpt-4o-mini-2024-07-18"],
+    snapshotBase: "gpt-4o-mini",
+    short: { input: 0.15 / M, cachedInput: 0.075 / M, output: 0.6 / M }
+  },
+  {
+    aliases: ["gpt-3.5-turbo"],
+    snapshotBase: "gpt-3.5-turbo",
+    short: { input: 0.5 / M, output: 1.5 / M }
+  },
+  {
+    aliases: ["o1", "o1-2024-12-17"],
+    snapshotBase: "o1",
+    short: { input: 15 / M, cachedInput: 7.5 / M, output: 60 / M }
+  },
+  {
+    aliases: ["o1-pro", "o1-pro-2025-03-19"],
+    snapshotBase: "o1-pro",
+    short: { input: 150 / M, output: 600 / M }
+  },
+  {
+    aliases: ["gpt-4.1", "gpt-4.1-2025-04-14"],
+    snapshotBase: "gpt-4.1",
+    short: { input: 2 / M, cachedInput: 0.5 / M, output: 8 / M }
+  },
+  {
+    aliases: ["gpt-4.1-mini", "gpt-4.1-mini-2025-04-14"],
+    snapshotBase: "gpt-4.1-mini",
+    short: { input: 0.4 / M, cachedInput: 0.1 / M, output: 1.6 / M }
+  },
+  {
+    aliases: ["gpt-4.1-nano", "gpt-4.1-nano-2025-04-14"],
+    snapshotBase: "gpt-4.1-nano",
+    short: { input: 0.1 / M, cachedInput: 0.025 / M, output: 0.4 / M }
+  },
+  {
+    aliases: ["o3", "o3-2025-04-16"],
+    snapshotBase: "o3",
+    short: { input: 2 / M, cachedInput: 0.5 / M, output: 8 / M }
+  },
+  {
+    aliases: ["o3-mini", "o3-mini-2025-01-31"],
+    snapshotBase: "o3-mini",
+    short: { input: 1.1 / M, cachedInput: 0.55 / M, output: 4.4 / M }
+  },
+  {
+    aliases: ["o3-pro", "o3-pro-2025-06-10"],
+    snapshotBase: "o3-pro",
+    short: { input: 20 / M, output: 80 / M }
+  },
+  {
+    aliases: ["o4-mini", "o4-mini-2025-04-16"],
+    snapshotBase: "o4-mini",
+    short: { input: 1.1 / M, cachedInput: 0.275 / M, output: 4.4 / M }
+  },
+  {
+    aliases: ["gpt-5", "gpt-5-2025-08-07"],
+    snapshotBase: "gpt-5",
+    short: { input: 1.25 / M, cachedInput: 0.125 / M, output: 10 / M }
+  },
+  {
+    aliases: ["gpt-5-mini", "gpt-5-mini-2025-08-07"],
+    snapshotBase: "gpt-5-mini",
+    short: { input: 0.25 / M, cachedInput: 0.025 / M, output: 2 / M }
+  },
+  {
+    aliases: ["gpt-5-nano", "gpt-5-nano-2025-08-07"],
+    snapshotBase: "gpt-5-nano",
+    short: { input: 0.05 / M, cachedInput: 5e-3 / M, output: 0.4 / M }
+  },
+  {
+    aliases: ["gpt-5.1", "gpt-5.1-2025-11-13"],
+    snapshotBase: "gpt-5.1",
+    short: { input: 1.25 / M, cachedInput: 0.125 / M, output: 10 / M }
+  },
+  {
+    aliases: ["gpt-5.2", "gpt-5.2-2025-12-11"],
+    snapshotBase: "gpt-5.2",
+    short: { input: 1.75 / M, cachedInput: 0.175 / M, output: 14 / M }
+  },
+  {
+    aliases: ["gpt-5.4", "gpt-5.4-2026-03-05"],
+    snapshotBase: "gpt-5.4",
+    short: { input: 2.5 / M, cachedInput: 0.25 / M, output: 15 / M },
+    long: withLongContext({ input: 2.5 / M, cachedInput: 0.25 / M, output: 15 / M }),
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
+  {
+    aliases: ["gpt-5.4-pro", "gpt-5.4-pro-2026-03-05"],
+    snapshotBase: "gpt-5.4-pro",
+    short: { input: 30 / M, output: 180 / M },
+    long: withLongContext({ input: 30 / M, output: 180 / M }),
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
+  {
+    aliases: ["gpt-5.5", "gpt-5.5-2026-04-23"],
+    snapshotBase: "gpt-5.5",
+    short: { input: 5 / M, cachedInput: 0.5 / M, output: 30 / M },
+    long: withLongContext({ input: 5 / M, cachedInput: 0.5 / M, output: 30 / M }),
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
+  {
+    aliases: ["gpt-5.5-pro", "gpt-5.5-pro-2026-04-23"],
+    snapshotBase: "gpt-5.5-pro",
+    short: { input: 30 / M, output: 180 / M },
+    long: withLongContext({ input: 30 / M, output: 180 / M }),
+    contextBoundary: LONG_CONTEXT_BOUNDARY
+  },
+  {
+    aliases: ["gpt-5.4-mini", "gpt-5.4-mini-2026-03-17"],
+    short: { input: 0.75 / M, cachedInput: 0.075 / M, output: 4.5 / M }
+  },
+  {
+    aliases: ["gpt-5.4-nano", "gpt-5.4-nano-2026-03-17"],
+    short: { input: 0.2 / M, cachedInput: 0.02 / M, output: 1.25 / M }
+  },
+  {
+    aliases: ["gpt-5.2-pro", "gpt-5.2-pro-2025-12-11"],
+    short: { input: 21 / M, output: 168 / M }
+  },
+  { aliases: ["gpt-5-pro", "gpt-5-pro-2025-10-06"], short: { input: 15 / M, output: 120 / M } },
+  { aliases: ["gpt-3.5-turbo-instruct"], short: { input: 1.5 / M, output: 2 / M } },
+  { aliases: ["davinci-002"], short: { input: 2 / M, output: 2 / M } },
+  { aliases: ["babbage-002"], short: { input: 0.4 / M, output: 0.4 / M } },
+  // Explicit snapshots with their own current dedicated-table rows. Do not
+  // generalize these dates: a plausible-looking unlisted snapshot is unpriced.
+  { aliases: ["gpt-4o-2024-05-13"], short: { input: 5 / M, output: 15 / M } },
+  { aliases: ["gpt-4-turbo-2024-04-09"], short: { input: 10 / M, output: 30 / M } },
+  { aliases: ["gpt-4-0613"], short: { input: 30 / M, output: 60 / M } },
+  {
+    aliases: ["gpt-3.5-turbo-0125"],
+    short: { input: 0.5 / M, output: 1.5 / M }
+  },
+  { aliases: ["gpt-3.5-turbo-1106"], short: { input: 1 / M, output: 2 / M } }
+];
+function directOpenAIModel(model) {
+  return DIRECT_OPENAI_CATALOG.find((entry) => entry.aliases.includes(model));
+}
+var CANONICAL_OPENAI_BASE_URL = "https://api.openai.com/v1";
+function isTextContentPart(value, type) {
+  return value !== null && typeof value === "object" && value.type === type && typeof value.text === "string";
+}
+function hasUnmodeledDirectOpenAIContent(request) {
+  if ("messages" in request) {
+    if (!Array.isArray(request.messages)) return true;
+    for (const message of request.messages) {
+      if (message === null || typeof message !== "object") return true;
+      const content = message.content;
+      if (content === void 0 || content === null || typeof content === "string") continue;
+      if (!Array.isArray(content) || content.some((part) => !isTextContentPart(part, "text"))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if ("input" in request) {
+    const input = request.input;
+    if (typeof input === "string") return false;
+    if (!Array.isArray(input)) return true;
+    for (const item of input) {
+      if (item === null || typeof item !== "object") return true;
+      const typed = item;
+      switch (typed.type) {
+        case "message": {
+          const content = typed.content;
+          if (typeof content === "string") break;
+          if (!Array.isArray(content) || content.some((part) => !isTextContentPart(part, "input_text"))) {
+            return true;
+          }
+          break;
+        }
+        case "function_call":
+          break;
+        case "function_call_output": {
+          const output = typed.output;
+          if (typeof output === "string") break;
+          if (!Array.isArray(output) || output.some((part) => !isTextContentPart(part, "input_text"))) {
+            return true;
+          }
+          break;
+        }
+        case "custom_tool_call":
+          if (typeof typed.input !== "string") return true;
+          break;
+        case "custom_tool_call_output":
+          if (typeof typed.output !== "string") return true;
+          break;
+        case "reasoning":
+          break;
+        default:
+          return true;
+      }
+    }
+    return false;
+  }
+  return false;
+}
+function isEligibleDirectOpenAIContext(context) {
+  const request = context?.request;
+  const response = context?.response;
+  if (context?.baseUrl !== void 0 && context.baseUrl !== CANONICAL_OPENAI_BASE_URL) return false;
+  if (request && hasUnmodeledDirectOpenAIContent(request)) return false;
+  const tier = response?.service_tier ?? response?.serviceTier ?? request?.service_tier ?? request?.serviceTier;
+  if (tier !== void 0 && (typeof tier !== "string" || !["standard", "default"].includes(tier.toLowerCase()))) {
+    return false;
+  }
+  if (["region", "inference_geo", "data_residency"].some((key) => request?.[key] !== void 0)) {
+    return false;
+  }
+  if (["previous_response_id", "conversation", "prompt"].some((key) => request?.[key] !== void 0)) {
+    return false;
+  }
+  const reasoning = request?.reasoning;
+  if (reasoning !== null && typeof reasoning === "object" && "mode" in reasoning && reasoning.mode !== void 0) {
+    return false;
+  }
+  if (request?.modalities !== void 0 && (!Array.isArray(request.modalities) || request.modalities.length === 0 || request.modalities.some((modality) => modality !== "text")) || ["audio", "image_generation", "web_search_options"].some((key) => request?.[key] !== void 0)) {
+    return false;
+  }
+  if (Array.isArray(request?.tools) && request.tools.some(
+    (tool2) => tool2 === null || typeof tool2 !== "object" || !["function", "custom"].includes(tool2.type)
+  )) {
+    return false;
+  }
+  return true;
+}
+function estimateDirectOpenAICost(model, usage, context) {
+  if (!isEligibleDirectOpenAIContext(context)) return void 0;
+  const entry = directOpenAIModel(model);
+  if (!entry) return void 0;
+  const { prompt_tokens, completion_tokens, cached_tokens, cache_write_tokens } = usage;
+  const cached = cached_tokens ?? 0;
+  const cacheWrite = cache_write_tokens ?? 0;
+  if (![prompt_tokens, completion_tokens, cached, cacheWrite].every(
+    (count) => Number.isSafeInteger(count) && count >= 0
+  ) || cached + cacheWrite > prompt_tokens) {
+    return void 0;
+  }
+  const rates = entry.long !== void 0 && entry.contextBoundary !== void 0 && prompt_tokens > entry.contextBoundary ? entry.long : entry.short;
+  if (cached > 0 && rates.cachedInput === void 0 || cacheWrite > 0 && rates.cacheWrite === void 0) {
+    return void 0;
+  }
+  const ordinary = prompt_tokens - cached - cacheWrite;
+  return ordinary * rates.input + cached * (rates.cachedInput ?? 0) + cacheWrite * (rates.cacheWrite ?? 0) + completion_tokens * rates.output;
+}
 function estimateOpenAICost(model, promptTokens, completionTokens, cachedTokens) {
-  return priceFromTable(OPENAI_PRICING, model, promptTokens, completionTokens, cachedTokens);
+  return estimateDirectOpenAICost(model, {
+    prompt_tokens: promptTokens,
+    completion_tokens: completionTokens,
+    total_tokens: promptTokens + completionTokens,
+    cached_tokens: cachedTokens
+  });
 }
 function isOSeriesModel(model) {
   return /^(o1|o3|o4-mini)/.test(model);
@@ -1276,6 +1650,15 @@ function isOSeriesModel(model) {
 function supportsReasoningEffort(model) {
   return isOSeriesModel(model) || /^gpt-5/.test(model);
 }
+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 supportsReasoningNone(model) {
   return /^gpt-5\.[1-9]/.test(model);
 }
@@ -1285,31 +1668,46 @@ function supportsXhigh(model) {
 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");
+  }
   if (effort === "xhigh" && !supportsXhigh(model)) return "high";
   return effort;
 }
-function effortToReasoningEffort(effort) {
-  return effort === "max" ? "xhigh" : effort;
+function effortToReasoningEffort(effort, model) {
+  return effort === "max" && model !== void 0 && supportsMaxReasoningEffort(model) ? "max" : effort === "max" ? "xhigh" : effort;
 }
 function budgetToReasoningEffort(budget) {
   if (budget <= 1024) return "low";
   if (budget <= 8192) return "medium";
   return "high";
 }
+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;
+}
+var warnedChatMaxDowngrades = /* @__PURE__ */ new Set();
+function resolveOpenAIChatReasoningEffort(model, resolved) {
+  const effort = resolveOpenAIReasoningEffort(model, resolved);
+  if (effort !== "max") return effort;
+  if (resolved.activeEffort === "max" && !warnedChatMaxDowngrades.has(model)) {
+    warnedChatMaxDowngrades.add(model);
+    console.warn(
+      `[axl] OpenAI Chat Completions does not accept effort "max" for ${model}; using "xhigh". Use the OpenAI Responses provider for native "max".`
+    );
+  }
+  return "xhigh";
+}
 var openaiReasoningEmit = (body, resolved, model) => {
   const oSeries = isOSeriesModel(model);
   const reasoningCapable = supportsReasoningEffort(model);
-  const { thinkingBudget, thinkingDisabled, activeEffort, hasBudgetOverride } = resolved;
-  let wireEffort;
-  if (reasoningCapable) {
-    if (hasBudgetOverride) {
-      wireEffort = clampReasoningEffort(model, budgetToReasoningEffort(thinkingBudget));
-    } else if (!thinkingDisabled && activeEffort) {
-      wireEffort = clampReasoningEffort(model, effortToReasoningEffort(activeEffort));
-    } else if (thinkingDisabled) {
-      wireEffort = clampReasoningEffort(model, "none");
-    }
-  }
+  const wireEffort = resolveOpenAIChatReasoningEffort(model, resolved);
   if (wireEffort) body.reasoning_effort = wireEffort;
   return { stripTemperature: oSeries || reasoningCapable && wireEffort !== void 0 };
 };
@@ -1319,7 +1717,7 @@ var OPENAI_PROFILE = {
   defaultBaseUrl: "https://api.openai.com/v1",
   envApiKey: "OPENAI_API_KEY",
   envBaseUrl: "OPENAI_BASE_URL",
-  pricing: { kind: "table", table: OPENAI_PRICING },
+  pricing: { kind: "table", table: OPENAI_PRICING, match: "exact" },
   reasoning: { emit: openaiReasoningEmit, capture: "none" },
   roleFor: (role, model) => role === "system" && isOSeriesModel(model) ? "developer" : role,
   maxTokensField: "max_completion_tokens",
@@ -1329,6 +1727,9 @@ var OpenAIProvider = class extends OpenAICompatibleProvider {
   constructor(options = {}) {
     super({ profile: OPENAI_PROFILE, ...options });
   }
+  computeCost(model, usage, _reportedCost, context) {
+    return usage ? estimateDirectOpenAICost(model, usage, { ...context, baseUrl: this.baseUrl }) : void 0;
+  }
 };
 
 // src/providers/openai-responses.ts
@@ -1389,7 +1790,7 @@ var OpenAIResponsesProvider = class {
       });
     }
     const json = await res.json();
-    return this.parseResponse(json, options.model);
+    return this.parseResponse(json, this.requestModel(body, options.model), body);
   }
   // ---------------------------------------------------------------------------
   // stream - SSE streaming
@@ -1421,30 +1822,23 @@ var OpenAIResponsesProvider = class {
     if (!res.body) {
       throw new Error("OpenAI Responses stream has no body");
     }
-    yield* this.parseSSEStream(res.body, options.model);
+    yield* this.parseSSEStream(res.body, this.requestModel(body, options.model), body);
   }
   // ---------------------------------------------------------------------------
   // Internal: build request body
   // ---------------------------------------------------------------------------
   buildRequestBody(messages, options, stream) {
-    const oSeries = isOSeriesModel(options.model);
-    const reasoningCapable = supportsReasoningEffort(options.model);
-    const { thinkingBudget, includeThoughts, thinkingDisabled, activeEffort, hasBudgetOverride } = resolveThinkingOptions(options);
-    let wireEffort;
-    if (reasoningCapable) {
-      if (hasBudgetOverride) {
-        wireEffort = clampReasoningEffort(options.model, budgetToReasoningEffort(thinkingBudget));
-      } else if (!thinkingDisabled && activeEffort) {
-        wireEffort = clampReasoningEffort(options.model, effortToReasoningEffort(activeEffort));
-      } else if (thinkingDisabled) {
-        wireEffort = clampReasoningEffort(options.model, "none");
-      }
-    }
+    const effectiveModel = typeof options.providerOptions?.model === "string" ? options.providerOptions.model : options.model;
+    const oSeries = isOSeriesModel(effectiveModel);
+    const reasoningCapable = supportsReasoningEffort(effectiveModel);
+    const resolved = resolveThinkingOptions(options);
+    const { includeThoughts } = resolved;
+    const wireEffort = resolveOpenAIReasoningEffort(effectiveModel, resolved);
     const stripTemp = oSeries || reasoningCapable && wireEffort !== void 0;
     const systemMessages = messages.filter((m) => m.role === "system");
     const nonSystemMessages = messages.filter((m) => m.role !== "system");
     const body = {
-      model: options.model,
+      model: effectiveModel,
       input: this.buildInput(nonSystemMessages),
       store: false,
       stream
@@ -1491,6 +1885,9 @@ var OpenAIResponsesProvider = class {
     }
     return body;
   }
+  requestModel(body, fallback) {
+    return typeof body.model === "string" ? body.model : fallback;
+  }
   // ---------------------------------------------------------------------------
   // Internal: message → input mapping
   // ---------------------------------------------------------------------------
@@ -1558,7 +1955,7 @@ var OpenAIResponsesProvider = class {
   // ---------------------------------------------------------------------------
   // Internal: parse non-streaming response
   // ---------------------------------------------------------------------------
-  parseResponse(json, model) {
+  parseResponse(json, model, request) {
     let content = "";
     let thinkingContent = "";
     const toolCalls = [];
@@ -1595,9 +1992,14 @@ var OpenAIResponsesProvider = class {
       completion_tokens: json.usage.output_tokens,
       total_tokens: json.usage.total_tokens,
       reasoning_tokens: json.usage.output_tokens_details?.reasoning_tokens,
-      cached_tokens: json.usage.input_tokens_details?.cached_tokens
+      cached_tokens: json.usage.input_tokens_details?.cached_tokens,
+      cache_write_tokens: json.usage.input_tokens_details?.cache_write_tokens
     } : void 0;
-    const cost = usage ? estimateOpenAICost(model, usage.prompt_tokens, usage.completion_tokens, usage.cached_tokens) : void 0;
+    const cost = usage ? estimateDirectOpenAICost(json.model ?? model, usage, {
+      baseUrl: this.baseUrl,
+      request,
+      response: json
+    }) : void 0;
     const providerMetadata = reasoningItems.length > 0 ? { openaiReasoningItems: reasoningItems } : void 0;
     return {
       content,
@@ -1611,7 +2013,7 @@ var OpenAIResponsesProvider = class {
   // ---------------------------------------------------------------------------
   // Internal: parse SSE stream
   // ---------------------------------------------------------------------------
-  async *parseSSEStream(body, model) {
+  async *parseSSEStream(body, model, request) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -1639,7 +2041,7 @@ var OpenAIResponsesProvider = class {
             } catch {
               continue;
             }
-            const chunk = this.handleStreamEvent(eventType, data, model, callIdMap);
+            const chunk = this.handleStreamEvent(eventType, data, model, callIdMap, request);
             if (chunk) {
               yield chunk;
               if (chunk.type === "done") return;
@@ -1653,7 +2055,7 @@ var OpenAIResponsesProvider = class {
       reader.releaseLock();
     }
   }
-  handleStreamEvent(eventType, data, model, callIdMap) {
+  handleStreamEvent(eventType, data, model, callIdMap, request) {
     switch (eventType) {
       case "response.output_text.delta":
         return { type: "text_delta", content: data.delta ?? "" };
@@ -1687,19 +2089,19 @@ var OpenAIResponsesProvider = class {
           completion_tokens: response.usage.output_tokens,
           total_tokens: response.usage.total_tokens,
           reasoning_tokens: response.usage.output_tokens_details?.reasoning_tokens,
-          cached_tokens: response.usage.input_tokens_details?.cached_tokens
+          cached_tokens: response.usage.input_tokens_details?.cached_tokens,
+          cache_write_tokens: response.usage.input_tokens_details?.cache_write_tokens
         } : void 0;
         const reasoningItems = response?.output?.filter((item) => item.type === "reasoning") ?? [];
         const providerMetadata = reasoningItems.length > 0 ? { openaiReasoningItems: reasoningItems } : void 0;
         return {
           type: "done",
           usage,
-          cost: usage ? estimateOpenAICost(
-            model,
-            usage.prompt_tokens,
-            usage.completion_tokens,
-            usage.cached_tokens
-          ) : void 0,
+          cost: usage ? estimateDirectOpenAICost(response?.model ?? model, usage, {
+            baseUrl: this.baseUrl,
+            request,
+            response
+          }) : void 0,
           providerMetadata
         };
       }
@@ -1733,68 +2135,357 @@ var OpenAIResponsesProvider = class {
 
 // src/providers/anthropic.ts
 var ANTHROPIC_API_VERSION = "2023-06-01";
-var ANTHROPIC_PRICING = {
-  "claude-opus-4-8": [5e-6, 25e-6],
-  "claude-opus-4-7": [5e-6, 25e-6],
-  "claude-opus-4-6": [5e-6, 25e-6],
-  "claude-sonnet-4-6": [3e-6, 15e-6],
-  "claude-opus-4-5": [5e-6, 25e-6],
-  "claude-opus-4-1": [15e-6, 75e-6],
-  "claude-sonnet-4-5": [3e-6, 15e-6],
-  "claude-haiku-4-5": [1e-6, 5e-6],
-  "claude-sonnet-4": [3e-6, 15e-6],
-  "claude-opus-4": [15e-6, 75e-6],
-  "claude-3-7-sonnet": [3e-6, 15e-6],
-  "claude-3-5-sonnet": [3e-6, 15e-6],
-  "claude-3-5-haiku": [8e-7, 4e-6],
-  "claude-3-opus": [15e-6, 75e-6],
-  "claude-3-sonnet": [3e-6, 15e-6],
-  "claude-3-haiku": [25e-8, 125e-8]
+var CLAUDE_CAPABILITIES = {
+  "claude-fable-5": {
+    thinking: "adaptive-always-on",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true
+  },
+  "claude-opus-5": {
+    thinking: "adaptive-default-on",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true,
+    disableAt: "high"
+  },
+  "claude-sonnet-5": {
+    thinking: "adaptive-default-on",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true,
+    disableAt: "max"
+  },
+  "claude-opus-4-8": {
+    thinking: "adaptive-optional",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true
+  },
+  "claude-opus-4-7": {
+    thinking: "adaptive-optional",
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    manualBudget: false,
+    stripTemperature: true
+  },
+  "claude-opus-4-6": {
+    thinking: "adaptive-optional",
+    effortLevels: ["low", "medium", "high", "max"],
+    manualBudget: true
+  },
+  "claude-sonnet-4-6": {
+    thinking: "adaptive-optional",
+    effortLevels: ["low", "medium", "high", "max"],
+    manualBudget: true
+  },
+  "claude-opus-4-5": {
+    thinking: "effort-only",
+    effortLevels: ["low", "medium", "high"],
+    manualBudget: true
+  },
+  "claude-opus-4-5-20251101": {
+    thinking: "effort-only",
+    effortLevels: ["low", "medium", "high"],
+    manualBudget: true
+  }
 };
-var ANTHROPIC_PRICING_KEYS_BY_LENGTH = Object.keys(ANTHROPIC_PRICING).sort(
-  (a, b) => b.length - a.length
-);
-function estimateAnthropicCost(model, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens) {
-  let pricing = ANTHROPIC_PRICING[model];
-  if (!pricing) {
-    for (const key of ANTHROPIC_PRICING_KEYS_BY_LENGTH) {
-      if (model.startsWith(key)) {
-        pricing = ANTHROPIC_PRICING[key];
-        break;
-      }
-    }
+var LEGACY_CLAUDE_CAPABILITY = {
+  thinking: "legacy-manual",
+  manualBudget: true
+};
+var LEGACY_CLAUDE_MODELS = /* @__PURE__ */ new Set([
+  "claude-opus-4-1",
+  "claude-opus-4-1-20250805",
+  "claude-sonnet-4-5",
+  "claude-sonnet-4-5-20250929",
+  "claude-haiku-4-5",
+  "claude-haiku-4-5-20251001",
+  "claude-sonnet-4",
+  "claude-sonnet-4-20250514",
+  "claude-opus-4",
+  "claude-opus-4-20250514",
+  "claude-3-7-sonnet",
+  "claude-3-7-sonnet-20250219",
+  "claude-3-5-sonnet",
+  "claude-3-5-sonnet-20241022",
+  "claude-3-5-sonnet-20240620",
+  "claude-3-5-haiku",
+  "claude-3-5-haiku-20241022",
+  "claude-3-opus",
+  "claude-3-opus-20240229",
+  "claude-3-sonnet",
+  "claude-3-sonnet-20240229",
+  "claude-3-haiku",
+  "claude-3-haiku-20240307"
+]);
+var PRE_INFERENCE_GEO_MODELS = /* @__PURE__ */ new Set([
+  ...LEGACY_CLAUDE_MODELS,
+  "claude-opus-4-5",
+  "claude-opus-4-5-20251101"
+]);
+function resolveClaudeCapability(model) {
+  return CLAUDE_CAPABILITIES[model] ?? (LEGACY_CLAUDE_MODELS.has(model) ? LEGACY_CLAUDE_CAPABILITY : void 0);
+}
+var ANTHROPIC_RATES = {
+  "claude-fable-5": { input: 1e-5, output: 5e-5 },
+  "claude-opus-5": { input: 5e-6, output: 25e-6 },
+  "claude-sonnet-5": { input: 3e-6, output: 15e-6, sonnet5Intro: true },
+  "claude-opus-4-8": { input: 5e-6, output: 25e-6 },
+  "claude-opus-4-7": { input: 5e-6, output: 25e-6 },
+  "claude-opus-4-6": { input: 5e-6, output: 25e-6 },
+  "claude-sonnet-4-6": { input: 3e-6, output: 15e-6 },
+  "claude-opus-4-5": { input: 5e-6, output: 25e-6 },
+  "claude-opus-4-5-20251101": { input: 5e-6, output: 25e-6 },
+  "claude-opus-4-1": { input: 15e-6, output: 75e-6 },
+  "claude-opus-4-1-20250805": { input: 15e-6, output: 75e-6 },
+  "claude-sonnet-4-5": { input: 3e-6, output: 15e-6 },
+  "claude-sonnet-4-5-20250929": { input: 3e-6, output: 15e-6 },
+  "claude-haiku-4-5": { input: 1e-6, output: 5e-6 },
+  "claude-haiku-4-5-20251001": { input: 1e-6, output: 5e-6 }
+};
+function isValidTokenCount(value) {
+  return value !== void 0 && Number.isSafeInteger(value) && value >= 0;
+}
+function estimateAnthropicCost(model, usage, now = /* @__PURE__ */ new Date()) {
+  if (!model || !isValidTokenCount(usage.inputTokens) || !isValidTokenCount(usage.outputTokens)) {
+    return void 0;
   }
-  if (!pricing) return void 0;
-  const [inputRate, outputRate] = pricing;
-  const cacheRead = cacheReadTokens ?? 0;
-  const cacheWrite = cacheWriteTokens ?? 0;
-  const inputCost = (inputTokens - cacheRead - cacheWrite) * inputRate + cacheRead * inputRate * 0.1 + cacheWrite * inputRate * 1.25;
-  return inputCost + outputTokens * outputRate;
+  const rate = ANTHROPIC_RATES[model];
+  if (!rate) return void 0;
+  const cacheRead = usage.cacheReadTokens ?? 0;
+  const cacheWrite5m = usage.cacheWrite5mTokens ?? 0;
+  const cacheWrite1h = usage.cacheWrite1hTokens ?? 0;
+  if (!isValidTokenCount(cacheRead) || !isValidTokenCount(cacheWrite5m) || !isValidTokenCount(cacheWrite1h)) {
+    return void 0;
+  }
+  const cacheWriteTotal = safeTokenSum(cacheWrite5m, cacheWrite1h);
+  if (cacheWriteTotal === void 0 || safeTokenSum(usage.inputTokens, cacheRead, cacheWriteTotal) === void 0) {
+    return void 0;
+  }
+  if (usage.aggregateCacheWriteTokens !== void 0 && (!isValidTokenCount(usage.aggregateCacheWriteTokens) || usage.aggregateCacheWriteTokens !== cacheWriteTotal)) {
+    return void 0;
+  }
+  const { input, output } = rate.sonnet5Intro && now < /* @__PURE__ */ new Date("2026-09-01T00:00:00Z") ? { input: 2e-6, output: 1e-5 } : rate;
+  return usage.inputTokens * input + cacheRead * input * 0.1 + cacheWrite5m * input * 1.25 + cacheWrite1h * input * 2 + usage.outputTokens * output;
 }
 var THINKING_BUDGETS = {
   low: 1024,
   medium: 5e3,
   high: 1e4,
+  xhigh: 2e4,
   // 30000 (not 32000) to stay under the 32K max_tokens limit on Opus 4/4.1.
   // With auto-bump (+1024), max_tokens becomes 31024 which fits all models.
   max: 3e4
 };
-function supportsAdaptiveThinking(model) {
-  return model.startsWith("claude-opus-4-8") || model.startsWith("claude-opus-4-7") || model.startsWith("claude-opus-4-6") || model.startsWith("claude-sonnet-4-6");
+function clampAnthropicEffort(capability, effort) {
+  const levels = capability.effortLevels;
+  if (!levels) return effort === "max" || effort === "xhigh" ? "high" : effort;
+  if (levels.includes(effort)) return effort;
+  return "high";
 }
-function supportsMaxEffort(model) {
-  return model.startsWith("claude-opus-4-8") || model.startsWith("claude-opus-4-7") || model.startsWith("claude-opus-4-6");
+function budgetToClaudeEffort(budget) {
+  if (budget <= THINKING_BUDGETS.low) return "low";
+  if (budget <= THINKING_BUDGETS.medium) return "medium";
+  if (budget <= THINKING_BUDGETS.high) return "high";
+  if (budget <= THINKING_BUDGETS.xhigh) return "xhigh";
+  return "max";
+}
+var warnedFableDisable = /* @__PURE__ */ new Set();
+function warnFableDisable(model) {
+  if (warnedFableDisable.has(model)) return;
+  warnedFableDisable.add(model);
+  console.warn(
+    `[axl] thinking cannot be disabled on Anthropic ${model}; using adaptive thinking at effort 'low'.`
+  );
 }
-function supportsXhigh2(model) {
-  return model.startsWith("claude-opus-4-8") || model.startsWith("claude-opus-4-7");
+function resolveClaudeThinking(model, resolved) {
+  const capability = resolveClaudeCapability(model);
+  if (!capability) return { stripTemperature: false };
+  const activeEffort = resolved.activeEffort ? clampAnthropicEffort(capability, resolved.activeEffort) : void 0;
+  const isClaude5 = capability.thinking === "adaptive-default-on" || capability.thinking === "adaptive-always-on";
+  if (isClaude5) {
+    if (resolved.hasBudgetOverride) {
+      const effort = clampAnthropicEffort(
+        capability,
+        budgetToClaudeEffort(resolved.thinkingBudget)
+      );
+      return {
+        thinking: { type: "adaptive" },
+        outputConfig: { effort },
+        stripTemperature: true
+      };
+    }
+    if (resolved.thinkingDisabled) {
+      if (capability.thinking === "adaptive-always-on") {
+        warnFableDisable(model);
+        return {
+          thinking: { type: "adaptive" },
+          outputConfig: { effort: "low" },
+          stripTemperature: true
+        };
+      }
+      if (activeEffort && capability.disableAt && !isEffortAtOrBelow(activeEffort, capability.disableAt)) {
+        return {
+          thinking: { type: "adaptive" },
+          outputConfig: { effort: activeEffort },
+          stripTemperature: true
+        };
+      }
+      return {
+        thinking: { type: "disabled" },
+        outputConfig: activeEffort ? { effort: activeEffort } : void 0,
+        stripTemperature: true
+      };
+    }
+    return activeEffort ? {
+      thinking: { type: "adaptive" },
+      outputConfig: { effort: activeEffort },
+      stripTemperature: true
+    } : { stripTemperature: true };
+  }
+  if (resolved.hasBudgetOverride) {
+    if (!capability.manualBudget) {
+      const effort = clampAnthropicEffort(
+        capability,
+        budgetToClaudeEffort(resolved.thinkingBudget)
+      );
+      return capability.thinking === "adaptive-optional" ? {
+        thinking: { type: "adaptive" },
+        outputConfig: { effort },
+        stripTemperature: capability.stripTemperature ?? true
+      } : { outputConfig: { effort }, stripTemperature: capability.stripTemperature ?? false };
+    }
+    return {
+      thinking: { type: "enabled", budget_tokens: resolved.thinkingBudget },
+      outputConfig: activeEffort && capability.effortLevels ? { effort: activeEffort } : void 0,
+      manualBudget: resolved.thinkingBudget,
+      stripTemperature: capability.stripTemperature ?? true
+    };
+  }
+  if (resolved.thinkingDisabled) {
+    return {
+      outputConfig: activeEffort && capability.effortLevels ? { effort: activeEffort } : void 0,
+      stripTemperature: capability.stripTemperature ?? false
+    };
+  }
+  if (activeEffort && capability.thinking === "adaptive-optional") {
+    return {
+      thinking: { type: "adaptive" },
+      outputConfig: { effort: activeEffort },
+      stripTemperature: capability.stripTemperature ?? true
+    };
+  }
+  if (activeEffort && capability.thinking === "effort-only") {
+    return { outputConfig: { effort: activeEffort }, stripTemperature: false };
+  }
+  if (activeEffort) {
+    const budget = THINKING_BUDGETS[activeEffort] ?? THINKING_BUDGETS.medium;
+    return {
+      thinking: { type: "enabled", budget_tokens: budget },
+      manualBudget: budget,
+      stripTemperature: true
+    };
+  }
+  return { stripTemperature: capability.stripTemperature ?? false };
 }
-function supportsEffort(model) {
-  return model.startsWith("claude-opus-4-8") || model.startsWith("claude-opus-4-7") || model.startsWith("claude-opus-4-6") || model.startsWith("claude-sonnet-4-6") || model.startsWith("claude-opus-4-5");
+function isEffortAtOrBelow(effort, ceiling) {
+  const levels = ["low", "medium", "high", "xhigh", "max"];
+  return levels.indexOf(effort) <= levels.indexOf(ceiling);
 }
-function clampAnthropicEffort(model, effort) {
-  if (effort === "max" && !supportsMaxEffort(model)) return "high";
-  if (effort === "xhigh" && !supportsXhigh2(model)) return "high";
-  return effort;
+function pricingContextFromBody(body) {
+  return {
+    model: typeof body.model === "string" ? body.model : void 0,
+    unpricedModifier: isAnthropicModifier("inference_geo", body.inference_geo) || isAnthropicModifier("speed", body.speed) || hasAnthropicServerTool(body.tools) || body.fallbacks !== void 0
+  };
+}
+function isModifiedAnthropicResponse(json, model) {
+  return isAnthropicResponseModifier("inference_geo", json.inference_geo, model) || isAnthropicResponseModifier("speed", json.speed, model) || isAnthropicResponseModifier("inference_geo", json.usage?.inference_geo, model) || isAnthropicResponseModifier("speed", json.usage?.speed, model) || hasBilledUnmodeledUsage(json.usage?.server_tool_use) || hasUnmodeledIterations(json.usage?.iterations);
+}
+function isAnthropicModifier(kind, value) {
+  if (value === void 0) return false;
+  return kind === "speed" ? value !== "standard" : value !== "global";
+}
+function isAnthropicResponseModifier(kind, value, model) {
+  if (value === void 0) return false;
+  if (kind === "speed") return value !== "standard";
+  if (value === "global") return false;
+  return value !== "not_available" || model === void 0 || !PRE_INFERENCE_GEO_MODELS.has(model);
+}
+function hasAnthropicServerTool(tools) {
+  return Array.isArray(tools) && tools.some(
+    (tool2) => tool2 !== null && typeof tool2 === "object" && typeof tool2.type === "string"
+  );
+}
+function hasBilledUnmodeledUsage(value) {
+  return value !== void 0 && value !== 0;
+}
+function hasUnmodeledIterations(value) {
+  return value !== void 0;
+}
+function hasFallbackIteration(value) {
+  return Array.isArray(value) && value.some(
+    (iteration) => iteration !== null && typeof iteration === "object" && iteration.type === "fallback_message"
+  );
+}
+function safeTokenSum(...values) {
+  const total = values.reduce((sum, value) => sum + value, 0);
+  return Number.isSafeInteger(total) ? total : void 0;
+}
+function normalizeAnthropicUsage(raw) {
+  const inputTokens = raw.input_tokens;
+  const outputTokens = raw.output_tokens;
+  const cacheReadTokens = raw.cache_read_input_tokens ?? 0;
+  const cacheWrite5mTokens = raw.cache_creation?.ephemeral_5m_input_tokens ?? 0;
+  const cacheWrite1hTokens = raw.cache_creation?.ephemeral_1h_input_tokens ?? 0;
+  if (!isValidTokenCount(inputTokens) || !isValidTokenCount(outputTokens) || !isValidTokenCount(cacheReadTokens) || !isValidTokenCount(cacheWrite5mTokens) || !isValidTokenCount(cacheWrite1hTokens)) {
+    return void 0;
+  }
+  const hasTtlBreakdown = raw.cache_creation?.ephemeral_5m_input_tokens !== void 0 || raw.cache_creation?.ephemeral_1h_input_tokens !== void 0;
+  const aggregateCacheWriteTokens = raw.cache_creation_input_tokens;
+  const normalizedCacheWrite = hasTtlBreakdown ? safeTokenSum(cacheWrite5mTokens, cacheWrite1hTokens) : void 0;
+  if (hasTtlBreakdown && normalizedCacheWrite === void 0) return void 0;
+  const promptCacheWrite = aggregateCacheWriteTokens ?? normalizedCacheWrite ?? 0;
+  if (!isValidTokenCount(promptCacheWrite)) return void 0;
+  const promptTokens = safeTokenSum(inputTokens, cacheReadTokens, promptCacheWrite);
+  if (promptTokens === void 0) return void 0;
+  const totalTokens = safeTokenSum(promptTokens, outputTokens);
+  if (totalTokens === void 0) return void 0;
+  return {
+    usage: {
+      prompt_tokens: promptTokens,
+      completion_tokens: outputTokens,
+      total_tokens: totalTokens,
+      cached_tokens: cacheReadTokens > 0 ? cacheReadTokens : void 0,
+      // The aggregate is still useful public usage telemetry even though it
+      // cannot be priced without the 5m/1h split. Keep pricingUsage separate
+      // so estimateAnthropicCost continues to fail closed in that case.
+      cache_write_tokens: (normalizedCacheWrite ?? aggregateCacheWriteTokens ?? 0) > 0 ? normalizedCacheWrite ?? aggregateCacheWriteTokens : void 0
+    },
+    pricingUsage: {
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWrite5mTokens,
+      cacheWrite1hTokens,
+      aggregateCacheWriteTokens
+    }
+  };
+}
+function mergeAnthropicUsage(initial, update) {
+  return {
+    input_tokens: update.input_tokens ?? initial?.input_tokens,
+    output_tokens: update.output_tokens ?? initial?.output_tokens,
+    cache_read_input_tokens: update.cache_read_input_tokens ?? initial?.cache_read_input_tokens,
+    cache_creation_input_tokens: update.cache_creation_input_tokens ?? initial?.cache_creation_input_tokens,
+    cache_creation: {
+      ephemeral_5m_input_tokens: update.cache_creation?.ephemeral_5m_input_tokens ?? initial?.cache_creation?.ephemeral_5m_input_tokens,
+      ephemeral_1h_input_tokens: update.cache_creation?.ephemeral_1h_input_tokens ?? initial?.cache_creation?.ephemeral_1h_input_tokens
+    },
+    speed: update.speed ?? initial?.speed,
+    inference_geo: update.inference_geo ?? initial?.inference_geo,
+    iterations: update.iterations ?? initial?.iterations,
+    server_tool_use: update.server_tool_use ?? initial?.server_tool_use
+  };
 }
 var AnthropicProvider = class {
   name = "anthropic";
@@ -1832,6 +2523,7 @@ var AnthropicProvider = class {
   async chat(messages, options) {
     const headers = this.buildHeaders(await this.resolveKey());
     const body = this.buildRequestBody(messages, options, false);
+    const pricingContext = pricingContextFromBody(body);
     const res = await fetchWithRetry(
       `${this.baseUrl}/messages`,
       {
@@ -1854,7 +2546,7 @@ var AnthropicProvider = class {
       });
     }
     const json = await res.json();
-    return this.parseResponse(json, options.model);
+    return this.parseResponse(json, pricingContext);
   }
   // ---------------------------------------------------------------------------
   // stream - SSE streaming completion
@@ -1862,6 +2554,7 @@ var AnthropicProvider = class {
   async *stream(messages, options) {
     const headers = this.buildHeaders(await this.resolveKey());
     const body = this.buildRequestBody(messages, options, true);
+    const pricingContext = pricingContextFromBody(body);
     const res = await fetchWithRetry(
       `${this.baseUrl}/messages`,
       {
@@ -1886,7 +2579,7 @@ var AnthropicProvider = class {
     if (!res.body) {
       throw new Error("Anthropic stream response has no body");
     }
-    yield* this.parseSSEStream(res.body, options.model);
+    yield* this.parseSSEStream(res.body, pricingContext);
   }
   // ---------------------------------------------------------------------------
   // Internal: request building
@@ -1910,11 +2603,12 @@ var AnthropicProvider = class {
     return `Anthropic API error (${status}): ${body}`;
   }
   buildRequestBody(messages, options, stream) {
+    const effectiveModel = typeof options.providerOptions?.model === "string" ? options.providerOptions.model : options.model;
     const systemMessages = messages.filter((m) => m.role === "system");
     const nonSystemMessages = messages.filter((m) => m.role !== "system");
     const systemText = systemMessages.map((m) => m.content).join("\n\n");
     const body = {
-      model: options.model,
+      model: effectiveModel,
       messages: this.mapMessages(nonSystemMessages),
       max_tokens: options.maxTokens ?? 4096,
       stream
@@ -1931,35 +2625,16 @@ var AnthropicProvider = class {
     if (options.toolChoice !== void 0) {
       body.tool_choice = this.mapToolChoice(options.toolChoice);
     }
-    const { thinkingBudget, thinkingDisabled, activeEffort, hasBudgetOverride } = resolveThinkingOptions(options);
-    const resolvedEffort = activeEffort ? clampAnthropicEffort(options.model, activeEffort) : void 0;
-    if (hasBudgetOverride) {
-      body.thinking = { type: "enabled", budget_tokens: thinkingBudget };
-      const currentMax = body.max_tokens;
-      if (currentMax < thinkingBudget + 1024) {
-        body.max_tokens = thinkingBudget + 1024;
-      }
-      if (resolvedEffort && supportsEffort(options.model)) {
-        body.output_config = { effort: resolvedEffort };
-      }
-    } else if (thinkingDisabled) {
-      if (resolvedEffort && supportsEffort(options.model)) {
-        body.output_config = { effort: resolvedEffort };
-      }
-    } else if (resolvedEffort && supportsAdaptiveThinking(options.model)) {
-      body.thinking = { type: "adaptive" };
-      body.output_config = { effort: resolvedEffort };
-    } else if (resolvedEffort && supportsEffort(options.model)) {
-      body.output_config = { effort: resolvedEffort };
-    } else if (resolvedEffort) {
-      const budget = THINKING_BUDGETS[resolvedEffort] ?? 5e3;
-      body.thinking = { type: "enabled", budget_tokens: budget };
+    const thinking = resolveClaudeThinking(effectiveModel, resolveThinkingOptions(options));
+    if (thinking.thinking) body.thinking = thinking.thinking;
+    if (thinking.outputConfig) body.output_config = thinking.outputConfig;
+    if (thinking.manualBudget) {
       const currentMax = body.max_tokens;
-      if (currentMax < budget + 1024) {
-        body.max_tokens = budget + 1024;
+      if (currentMax < thinking.manualBudget + 1024) {
+        body.max_tokens = thinking.manualBudget + 1024;
       }
     }
-    if (options.temperature !== void 0 && !body.thinking) {
+    if (options.temperature !== void 0 && !thinking.stripTemperature) {
       body.temperature = options.temperature;
     }
     if (options.responseFormat && options.responseFormat.type !== "text") {
@@ -1984,8 +2659,9 @@ ${jsonInstruction}` : jsonInstruction;
     const result = [];
     for (const msg of messages) {
       if (msg.role === "assistant") {
+        const replayedThinking = this.getReplayedThinkingBlocks(msg);
         if (msg.tool_calls && msg.tool_calls.length > 0) {
-          const content = [];
+          const content = [...replayedThinking];
           if (msg.content) {
             content.push({ type: "text", text: msg.content });
           }
@@ -2004,6 +2680,10 @@ ${jsonInstruction}` : jsonInstruction;
             });
           }
           result.push({ role: "assistant", content });
+        } else if (replayedThinking.length > 0) {
+          const content = [...replayedThinking];
+          if (msg.content) content.push({ type: "text", text: msg.content });
+          result.push({ role: "assistant", content });
         } else {
           result.push({ role: "assistant", content: msg.content });
         }
@@ -2024,6 +2704,13 @@ ${jsonInstruction}` : jsonInstruction;
     }
     return this.mergeConsecutiveRoles(result);
   }
+  getReplayedThinkingBlocks(msg) {
+    const blocks = msg.providerMetadata?.anthropicThinkingBlocks;
+    if (!Array.isArray(blocks)) return [];
+    return blocks.filter(
+      (block) => block !== null && typeof block === "object" && (block.type === "thinking" || block.type === "redacted_thinking")
+    );
+  }
   /**
    * Merge consecutive messages with the same role into a single message.
    * This handles cases where multiple tool_result blocks need to be in one user message.
@@ -2079,16 +2766,24 @@ ${jsonInstruction}` : jsonInstruction;
   // ---------------------------------------------------------------------------
   // Internal: response parsing
   // ---------------------------------------------------------------------------
-  parseResponse(json, model) {
+  parseResponse(json, pricingContext) {
     let content = "";
     let thinkingContent = "";
     const toolCalls = [];
-    for (const block of json.content) {
+    const thinkingBlocks = [];
+    const fallbackIndex = lastFallbackIndex(json.content);
+    const hasFallbackBoundary = fallbackIndex >= 0 || hasFallbackIteration(json.usage?.iterations);
+    let refused = json.stop_reason === "refusal";
+    for (const [index, block] of json.content.entries()) {
       if (block.type === "thinking") {
         thinkingContent += block.thinking;
+        thinkingBlocks.push(block);
+      } else if (block.type === "redacted_thinking") {
+        thinkingBlocks.push(block);
       } else if (block.type === "text") {
         content += block.text;
       } else if (block.type === "tool_use") {
+        if (fallbackIndex >= 0 && index < fallbackIndex) continue;
         toolCalls.push({
           id: block.id,
           type: "function",
@@ -2097,37 +2792,58 @@ ${jsonInstruction}` : jsonInstruction;
             arguments: JSON.stringify(block.input)
           }
         });
+      } else if (block.type === "fallback") {
+      } else if (block.type === "refusal") {
+        refused = true;
       }
     }
-    const cacheRead = json.usage?.cache_read_input_tokens ?? 0;
-    const cacheWrite = json.usage?.cache_creation_input_tokens ?? 0;
-    const totalInput = (json.usage?.input_tokens ?? 0) + cacheRead + cacheWrite;
-    const usage = json.usage ? {
-      prompt_tokens: totalInput,
-      completion_tokens: json.usage.output_tokens,
-      total_tokens: totalInput + json.usage.output_tokens,
-      cached_tokens: cacheRead > 0 ? cacheRead : void 0
-    } : void 0;
-    const cost = json.usage ? estimateAnthropicCost(model, totalInput, json.usage.output_tokens, cacheRead, cacheWrite) : void 0;
+    const normalized = json.usage ? normalizeAnthropicUsage(json.usage) : void 0;
+    const effectiveModel = typeof json.model === "string" ? json.model : pricingContext.model;
+    if (hasFallbackBoundary) {
+      throw new Error(
+        "Anthropic fallback responses cannot be continued safely; retry without fallbacks."
+      );
+    }
+    const cost = normalized && !pricingContext.unpricedModifier && !isModifiedAnthropicResponse(json, effectiveModel) && !hasFallbackBoundary && !refused ? estimateAnthropicCost(effectiveModel, normalized.pricingUsage) : void 0;
     return {
       content,
       thinking_content: thinkingContent || void 0,
       tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
-      usage,
-      cost
+      usage: normalized?.usage,
+      cost,
+      providerMetadata: thinkingBlocks.length > 0 && !hasFallbackBoundary ? { anthropicThinkingBlocks: thinkingBlocks } : void 0
     };
   }
   // ---------------------------------------------------------------------------
   // Internal: SSE stream parsing
   // ---------------------------------------------------------------------------
-  async *parseSSEStream(body, model) {
+  async *parseSSEStream(body, pricingContext) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
     let currentToolId = "";
     let currentToolName = "";
     let usage;
-    let cacheWrite = 0;
+    let pricingUsage;
+    let rawUsage;
+    const thinkingBlocks = [];
+    let currentThinkingBlock;
+    let effectiveModel = pricingContext.model;
+    let unpricedModifier = pricingContext.unpricedModifier;
+    let hasFallbackBoundary = false;
+    let hasFallbackIterationSignal = false;
+    let refused = false;
+    const finalizeUsage = () => {
+      const normalized = rawUsage ? normalizeAnthropicUsage(rawUsage) : void 0;
+      usage = normalized?.usage;
+      pricingUsage = normalized?.pricingUsage;
+    };
+    const doneChunk = () => ({
+      type: "done",
+      usage,
+      cost: pricingUsage && !unpricedModifier && !hasFallbackBoundary && !refused ? estimateAnthropicCost(effectiveModel, pricingUsage) : void 0,
+      providerMetadata: thinkingBlocks.length > 0 && !hasFallbackBoundary && !hasFallbackIterationSignal ? { anthropicThinkingBlocks: thinkingBlocks } : void 0
+    });
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -2158,13 +2874,31 @@ ${jsonInstruction}` : jsonInstruction;
                   name: currentToolName,
                   arguments: ""
                 };
+              } else if (block?.type === "thinking" || block?.type === "redacted_thinking") {
+                currentThinkingBlock = {
+                  ...block,
+                  type: block.type
+                };
+              } else if (block?.type === "fallback") {
+                hasFallbackBoundary = true;
+              } else if (block?.type === "refusal") {
+                refused = true;
               }
               break;
             }
             case "content_block_delta": {
               const delta = event.delta;
               if (delta?.type === "thinking_delta" && delta.thinking) {
+                if (currentThinkingBlock?.type === "thinking") {
+                  const current = currentThinkingBlock.thinking;
+                  currentThinkingBlock.thinking = `${typeof current === "string" ? current : ""}${delta.thinking}`;
+                }
                 yield { type: "thinking_delta", content: delta.thinking };
+              } else if (delta?.type === "signature_delta" && delta.signature) {
+                if (currentThinkingBlock) {
+                  const current = currentThinkingBlock.signature;
+                  currentThinkingBlock.signature = `${typeof current === "string" ? current : ""}${delta.signature}`;
+                }
               } else if (delta?.type === "text_delta" && delta.text) {
                 yield { type: "text_delta", content: delta.text };
               } else if (delta?.type === "input_json_delta" && delta.partial_json) {
@@ -2177,76 +2911,82 @@ ${jsonInstruction}` : jsonInstruction;
               break;
             }
             case "content_block_stop": {
+              if (currentThinkingBlock) {
+                thinkingBlocks.push(currentThinkingBlock);
+                currentThinkingBlock = void 0;
+              }
               currentToolId = "";
               currentToolName = "";
               break;
             }
             case "message_start": {
               if (event.message?.usage) {
-                const cacheRead = event.message.usage.cache_read_input_tokens ?? 0;
-                cacheWrite = event.message.usage.cache_creation_input_tokens ?? 0;
-                const inputTokens = (event.message.usage.input_tokens ?? 0) + cacheRead + cacheWrite;
-                usage = {
-                  prompt_tokens: inputTokens,
-                  completion_tokens: 0,
-                  total_tokens: inputTokens,
-                  cached_tokens: cacheRead > 0 ? cacheRead : void 0
-                };
+                rawUsage = mergeAnthropicUsage(rawUsage, event.message.usage);
+              }
+              if (typeof event.message?.model === "string") effectiveModel = event.message.model;
+              const messageFallback = hasFallbackIteration(event.message?.usage?.iterations);
+              if (isAnthropicResponseModifier(
+                "inference_geo",
+                event.message?.inference_geo,
+                effectiveModel
+              ) || isAnthropicResponseModifier("speed", event.message?.speed, effectiveModel) || isAnthropicResponseModifier(
+                "inference_geo",
+                event.message?.usage?.inference_geo,
+                effectiveModel
+              ) || isAnthropicResponseModifier("speed", event.message?.usage?.speed, effectiveModel) || hasBilledUnmodeledUsage(event.message?.usage?.server_tool_use) || hasUnmodeledIterations(event.message?.usage?.iterations)) {
+                unpricedModifier = true;
               }
+              if (messageFallback) hasFallbackIterationSignal = true;
               break;
             }
             case "message_delta": {
               if (event.usage) {
-                const outputTokens = event.usage.output_tokens ?? 0;
-                if (usage) {
-                  usage.completion_tokens = outputTokens;
-                  usage.total_tokens = usage.prompt_tokens + outputTokens;
-                } else {
-                  usage = {
-                    prompt_tokens: 0,
-                    completion_tokens: outputTokens,
-                    total_tokens: outputTokens
-                  };
+                rawUsage = mergeAnthropicUsage(rawUsage, event.usage);
+                finalizeUsage();
+                const terminalFallback = hasFallbackIteration(event.usage.iterations);
+                if (isAnthropicResponseModifier("speed", event.usage.speed, effectiveModel) || isAnthropicResponseModifier(
+                  "inference_geo",
+                  event.usage.inference_geo,
+                  effectiveModel
+                ) || hasBilledUnmodeledUsage(event.usage.server_tool_use) || hasUnmodeledIterations(event.usage.iterations)) {
+                  unpricedModifier = true;
                 }
+                if (terminalFallback) hasFallbackIterationSignal = true;
               }
+              if (event.delta?.stop_reason === "refusal") refused = true;
               break;
             }
             case "message_stop": {
-              if (usage) {
-                usage.total_tokens = usage.prompt_tokens + usage.completion_tokens;
+              finalizeUsage();
+              if (hasFallbackBoundary || hasFallbackIterationSignal) {
+                throw new Error(
+                  "Anthropic fallback streams cannot be continued safely; retry without fallbacks."
+                );
               }
-              yield {
-                type: "done",
-                usage,
-                cost: usage ? estimateAnthropicCost(
-                  model,
-                  usage.prompt_tokens,
-                  usage.completion_tokens,
-                  usage.cached_tokens,
-                  cacheWrite
-                ) : void 0
-              };
+              yield doneChunk();
               return;
             }
           }
         }
       }
-      yield {
-        type: "done",
-        usage,
-        cost: usage ? estimateAnthropicCost(
-          model,
-          usage.prompt_tokens,
-          usage.completion_tokens,
-          usage.cached_tokens,
-          cacheWrite
-        ) : void 0
-      };
+      finalizeUsage();
+      if (hasFallbackBoundary || hasFallbackIterationSignal) {
+        throw new Error(
+          "Anthropic fallback streams cannot be continued safely; retry without fallbacks."
+        );
+      }
+      yield doneChunk();
     } finally {
       reader.releaseLock();
     }
   }
 };
+function lastFallbackIndex(blocks) {
+  for (let index = blocks.length - 1; index >= 0; index--) {
+    if (blocks[index].type === "fallback") return index;
+  }
+  return -1;
+}
 
 // src/providers/gemini.ts
 var GEMINI_DISALLOWED_SCHEMA_KEYS = /* @__PURE__ */ new Set([
@@ -2294,36 +3034,92 @@ function parseGeminiFunctionResponse(content) {
   return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { result: parsed };
 }
 var GEMINI_PRICING = {
-  "gemini-2.5-pro": [125e-8, 1e-5],
-  "gemini-2.5-flash": [3e-7, 25e-7],
-  "gemini-2.5-flash-lite": [1e-7, 4e-7],
-  "gemini-2.0-flash": [1e-7, 4e-7],
-  "gemini-2.0-flash-lite": [1e-7, 4e-7],
-  "gemini-3-pro-preview": [2e-6, 12e-6],
-  "gemini-3-flash-preview": [5e-7, 3e-6],
-  "gemini-3.1-pro-preview": [2e-6, 12e-6],
-  "gemini-3.1-flash-lite": [25e-8, 15e-7],
-  "gemini-3.1-flash-lite-preview": [25e-8, 15e-7],
-  "gemini-3.5-flash": [15e-7, 9e-6]
+  "gemini-2.5-pro": {
+    input: 125e-8,
+    cached: 125e-9,
+    output: 1e-5,
+    longContext: { input: 25e-7, cached: 25e-8, output: 15e-6 }
+  },
+  "gemini-2.5-flash": { input: 3e-7, cached: 3e-8, output: 25e-7 },
+  "gemini-2.5-flash-lite": { input: 1e-7, cached: 1e-8, output: 4e-7 },
+  "gemini-3-flash-preview": { input: 5e-7, cached: 5e-8, output: 3e-6 },
+  "gemini-3.1-pro-preview": {
+    input: 2e-6,
+    cached: 2e-7,
+    output: 12e-6,
+    longContext: { input: 4e-6, cached: 4e-7, output: 18e-6 }
+  },
+  "gemini-3.1-pro-preview-customtools": {
+    input: 2e-6,
+    cached: 2e-7,
+    output: 12e-6,
+    longContext: { input: 4e-6, cached: 4e-7, output: 18e-6 }
+  },
+  "gemini-3.1-flash-lite": { input: 25e-8, cached: 25e-9, output: 15e-7 },
+  "gemini-3.5-flash": { input: 15e-7, cached: 15e-8, output: 9e-6 },
+  "gemini-3.5-flash-lite": { input: 3e-7, cached: 3e-8, output: 25e-7 },
+  "gemini-3.6-flash": { input: 15e-7, cached: 15e-8, output: 75e-7 }
 };
-var GEMINI_PRICING_KEYS_BY_LENGTH = Object.keys(GEMINI_PRICING).sort(
-  (a, b) => b.length - a.length
-);
-function estimateGeminiCost(model, inputTokens, outputTokens, cachedTokens) {
-  let pricing = GEMINI_PRICING[model];
-  if (!pricing) {
-    for (const key of GEMINI_PRICING_KEYS_BY_LENGTH) {
-      if (model.startsWith(key)) {
-        pricing = GEMINI_PRICING[key];
-        break;
-      }
-    }
+function isValidTokenCount2(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isStandardGeminiRequestTier(value) {
+  return value === void 0 || value === "SERVICE_TIER_UNSPECIFIED" || value === "SERVICE_TIER_STANDARD";
+}
+function isDefinitiveStandardGeminiResponseTier(value) {
+  return value === "SERVICE_TIER_UNSPECIFIED" || value === "SERVICE_TIER_STANDARD" || value === "standard";
+}
+function isEligibleGeminiPricing(context, hasDefinitiveStandardResponseTier, hasInvalidResponseTier) {
+  return context.eligibleRequest && isStandardGeminiRequestTier(context.serviceTier) && hasDefinitiveStandardResponseTier && !hasInvalidResponseTier;
+}
+function estimateGeminiCost(model, usage) {
+  const pricing = GEMINI_PRICING[model];
+  const cached = usage.cachedTokens ?? 0;
+  if (!pricing || !isValidTokenCount2(usage.inputTokens) || !isValidTokenCount2(usage.outputTokens) || !isValidTokenCount2(cached) || cached > usage.inputTokens) {
+    return void 0;
   }
-  if (!pricing) return void 0;
-  const [inputRate, outputRate] = pricing;
-  const cached = cachedTokens ?? 0;
-  const inputCost = (inputTokens - cached) * inputRate + cached * inputRate * 0.1;
-  return inputCost + outputTokens * outputRate;
+  const rate = usage.inputTokens > 2e5 && pricing.longContext ? pricing.longContext : pricing;
+  return (usage.inputTokens - cached) * rate.input + cached * rate.cached + usage.outputTokens * rate.output;
+}
+function safeTokenSum2(...values) {
+  const total = values.reduce((sum, value) => sum + value, 0);
+  return Number.isSafeInteger(total) ? total : void 0;
+}
+function normalizeGeminiUsage(raw) {
+  const inputTokens = raw.promptTokenCount;
+  const completionTokens = raw.candidatesTokenCount;
+  const totalTokens = raw.totalTokenCount;
+  const cachedTokens = raw.cachedContentTokenCount ?? 0;
+  const reasoningTokens = raw.thoughtsTokenCount ?? 0;
+  const toolUsePromptTokens = raw.toolUsePromptTokenCount ?? 0;
+  if (!isValidTokenCount2(inputTokens) || !isValidTokenCount2(completionTokens) || !isValidTokenCount2(totalTokens) || !isValidTokenCount2(cachedTokens) || !isValidTokenCount2(reasoningTokens) || !isValidTokenCount2(toolUsePromptTokens) || cachedTokens > inputTokens) {
+    return void 0;
+  }
+  const billedOutputTokens = safeTokenSum2(completionTokens, reasoningTokens);
+  const expectedTotal = safeTokenSum2(
+    inputTokens,
+    completionTokens,
+    reasoningTokens,
+    toolUsePromptTokens
+  );
+  if (billedOutputTokens === void 0 || expectedTotal === void 0 || totalTokens !== expectedTotal) {
+    return void 0;
+  }
+  return {
+    usage: {
+      prompt_tokens: inputTokens,
+      completion_tokens: completionTokens,
+      total_tokens: totalTokens,
+      cached_tokens: cachedTokens > 0 ? cachedTokens : void 0,
+      reasoning_tokens: reasoningTokens > 0 ? reasoningTokens : void 0
+    },
+    pricingUsage: {
+      inputTokens,
+      outputTokens: billedOutputTokens,
+      cachedTokens
+    },
+    hasUnmodeledBilledUsage: toolUsePromptTokens !== 0
+  };
 }
 var THINKING_BUDGETS2 = {
   low: 1024,
@@ -2342,8 +3138,23 @@ var THINKING_LEVELS = {
   max: "high"
   // 3.x caps at 'high'
 };
+var GEMINI_3X_MIN_THINKING_LEVEL = /* @__PURE__ */ new Map([
+  ["gemini-3-pro-preview", "minimal"],
+  ["gemini-3-flash-preview", "minimal"],
+  ["gemini-3.1-pro-preview", "low"],
+  ["gemini-3.1-pro-preview-customtools", "low"],
+  ["gemini-3.1-flash-lite", "minimal"],
+  ["gemini-3.1-flash-lite-preview", "minimal"],
+  ["gemini-3.5-flash", "minimal"],
+  ["gemini-3.5-flash-lite", "minimal"],
+  ["gemini-3.6-flash", "minimal"]
+]);
+var GEMINI_MODELS_WITHOUT_PORTABLE_TEMPERATURE = /* @__PURE__ */ new Set([
+  "gemini-3.5-flash-lite",
+  "gemini-3.6-flash"
+]);
 function isGemini3x(model) {
-  return /^gemini-3[.-]/.test(model);
+  return GEMINI_3X_MIN_THINKING_LEVEL.has(model);
 }
 function budgetToThinkingLevel(budgetTokens) {
   if (budgetTokens <= 1024) return "low";
@@ -2351,8 +3162,7 @@ function budgetToThinkingLevel(budgetTokens) {
   return "high";
 }
 function minThinkingLevel(model) {
-  if (model.startsWith("gemini-3.1-pro")) return "low";
-  return "minimal";
+  return GEMINI_3X_MIN_THINKING_LEVEL.get(model) ?? "minimal";
 }
 var _warned3xEffortNone = /* @__PURE__ */ new Set();
 function warnGemini3xEffortNone(model) {
@@ -2397,10 +3207,12 @@ var GeminiProvider = class {
   // chat - non-streaming completion
   // ---------------------------------------------------------------------------
   async chat(messages, options) {
-    const headers = this.buildHeaders(await this.resolveKey());
     const body = this.buildRequestBody(messages, options);
+    const pricingContext = this.pricingContext(this.requestModel(options), body);
+    this.assertSafeGemini3Continuation(messages, pricingContext.model);
+    const headers = this.buildHeaders(await this.resolveKey());
     const res = await fetchWithRetry(
-      `${this.baseUrl}/models/${options.model}:generateContent`,
+      `${this.baseUrl}/models/${pricingContext.model}:generateContent`,
       {
         method: "POST",
         headers,
@@ -2421,16 +3233,18 @@ var GeminiProvider = class {
       });
     }
     const json = await res.json();
-    return this.parseResponse(json, options.model);
+    return this.parseResponse(json, pricingContext);
   }
   // ---------------------------------------------------------------------------
   // stream - SSE streaming completion
   // ---------------------------------------------------------------------------
   async *stream(messages, options) {
-    const headers = this.buildHeaders(await this.resolveKey());
     const body = this.buildRequestBody(messages, options);
+    const pricingContext = this.pricingContext(this.requestModel(options), body);
+    this.assertSafeGemini3Continuation(messages, pricingContext.model);
+    const headers = this.buildHeaders(await this.resolveKey());
     const res = await fetchWithRetry(
-      `${this.baseUrl}/models/${options.model}:streamGenerateContent?alt=sse`,
+      `${this.baseUrl}/models/${pricingContext.model}:streamGenerateContent?alt=sse`,
       {
         method: "POST",
         headers,
@@ -2453,7 +3267,7 @@ var GeminiProvider = class {
     if (!res.body) {
       throw new Error("Gemini stream response has no body");
     }
-    yield* this.parseSSEStream(res.body, options.model);
+    yield* this.parseSSEStream(res.body, pricingContext);
   }
   // ---------------------------------------------------------------------------
   // Internal: request building
@@ -2474,7 +3288,114 @@ var GeminiProvider = class {
     }
     return `Gemini API error (${status}): ${body}`;
   }
+  pricingContext(fallbackModel, body) {
+    return {
+      // Gemini's model is normally selected in the URL. providerOptions is an
+      // explicit raw escape hatch, so honor a post-merge model override for both
+      // the URL and pricing rather than pricing a different request.
+      model: typeof body.model === "string" ? body.model : fallbackModel,
+      serviceTier: body.serviceTier,
+      eligibleRequest: this.baseUrl === "https://generativelanguage.googleapis.com/v1beta" && this.isTextOnlyClientRequest(body)
+    };
+  }
+  requestModel(options) {
+    return typeof options.providerOptions?.model === "string" ? options.providerOptions.model : options.model;
+  }
+  assertSafeGemini3Continuation(messages, model) {
+    if (GEMINI_MODELS_WITHOUT_PORTABLE_TEMPERATURE.has(model)) {
+      const mapped = this.mapMessages(messages.filter((message) => message.role !== "system"));
+      if (mapped.at(-1)?.role === "model") {
+        throw new Error(
+          `${model} does not support a terminal assistant/model prefill; end the request with a user or tool message.`
+        );
+      }
+    }
+    if (!isGemini3x(model)) return;
+    const replayedNativeCallIds = /* @__PURE__ */ new Set();
+    for (const message of messages) {
+      if (message.role !== "assistant" || !Array.isArray(message.providerMetadata?.geminiParts)) {
+        continue;
+      }
+      for (const part of message.providerMetadata.geminiParts) {
+        const id = part !== null && typeof part === "object" ? part.functionCall?.id : void 0;
+        if (!id) continue;
+        if (replayedNativeCallIds.has(id)) {
+          throw new Error(
+            `${model} native functionCall ids must be globally unique across a replay.`
+          );
+        }
+        replayedNativeCallIds.add(id);
+      }
+    }
+    const consumedToolMessages = /* @__PURE__ */ new Set();
+    for (const [assistantIndex, message] of messages.entries()) {
+      if (message.role !== "assistant" || !message.tool_calls?.length) continue;
+      const rawParts = message.providerMetadata?.geminiParts;
+      if (!Array.isArray(rawParts)) {
+        throw new Error(
+          `${model} tool continuations require providerMetadata.geminiParts with thought signatures.`
+        );
+      }
+      const nativeCalls = rawParts.flatMap((part) => {
+        const functionCall = part !== null && typeof part === "object" ? part.functionCall : void 0;
+        return functionCall?.id ? [{ id: functionCall.id, name: functionCall.name, part }] : [];
+      });
+      const expectedCalls = new Map(
+        message.tool_calls.map((call) => [call.id, call.function.name])
+      );
+      if (expectedCalls.size !== message.tool_calls.length || nativeCalls.length !== message.tool_calls.length || new Set(nativeCalls.map((call) => call.id)).size !== nativeCalls.length || typeof nativeCalls[0]?.part.thoughtSignature !== "string" || nativeCalls[0].part.thoughtSignature.length === 0 || nativeCalls.some((call) => expectedCalls.get(call.id) !== call.name)) {
+        throw new Error(
+          `${model} tool continuations require exact native functionCall id/name and a thoughtSignature on the first function call.`
+        );
+      }
+      const seenResponses = /* @__PURE__ */ new Set();
+      let toolIndex = assistantIndex + 1;
+      while (messages[toolIndex]?.role === "tool") {
+        const toolMessage = messages[toolIndex];
+        const toolCallId = toolMessage.tool_call_id;
+        if (!toolCallId || !expectedCalls.has(toolCallId) || seenResponses.has(toolCallId)) {
+          throw new Error(
+            `${model} functionResponse requires exactly one matching native functionCall id and name.`
+          );
+        }
+        seenResponses.add(toolCallId);
+        consumedToolMessages.add(toolIndex);
+        toolIndex++;
+      }
+      if (seenResponses.size !== expectedCalls.size) {
+        throw new Error(
+          `${model} tool continuations require one contiguous functionResponse for every native functionCall.`
+        );
+      }
+    }
+    for (const [index, message] of messages.entries()) {
+      if (message.role === "tool" && !consumedToolMessages.has(index)) {
+        throw new Error(
+          `${model} functionResponse requires exactly one matching native functionCall id and name.`
+        );
+      }
+    }
+  }
+  isTextOnlyClientRequest(body) {
+    if (!Array.isArray(body.contents) || body.cachedContent !== void 0) return false;
+    if (body.contents.some(
+      (content) => content === null || typeof content !== "object" || !Array.isArray(content.parts) || content.parts.some((part) => this.isNonTextGeminiPart(part))
+    )) {
+      return false;
+    }
+    if (body.tools !== void 0 && (!Array.isArray(body.tools) || body.tools.some(
+      (tool2) => tool2 === null || typeof tool2 !== "object" || !Array.isArray(tool2.functionDeclarations) || Object.keys(tool2).some((key) => key !== "functionDeclarations")
+    ))) {
+      return false;
+    }
+    const modalities = body.generationConfig?.responseModalities;
+    return modalities === void 0 || modalities === "TEXT" || Array.isArray(modalities) && modalities.length === 1 && modalities[0] === "TEXT";
+  }
+  isNonTextGeminiPart(part) {
+    return part === null || typeof part !== "object" || ["inlineData", "fileData", "executableCode", "codeExecutionResult"].some((key) => key in part);
+  }
   buildRequestBody(messages, options) {
+    const requestModel = this.requestModel(options);
     const systemMessages = messages.filter((m) => m.role === "system");
     const nonSystemMessages = messages.filter((m) => m.role !== "system");
     const systemText = systemMessages.map((m) => m.content).join("\n\n");
@@ -2492,7 +3413,7 @@ var GeminiProvider = class {
       ];
     }
     const generationConfig = {};
-    if (options.temperature !== void 0) {
+    if (options.temperature !== void 0 && !GEMINI_MODELS_WITHOUT_PORTABLE_TEMPERATURE.has(requestModel)) {
       generationConfig.temperature = options.temperature;
     }
     if (options.maxTokens !== void 0) {
@@ -2521,18 +3442,18 @@ var GeminiProvider = class {
       hasBudgetOverride
     } = resolveThinkingOptions(options);
     if (thinkingDisabled) {
-      if (isGemini3x(options.model)) {
+      if (isGemini3x(requestModel)) {
         if (effort === "none") {
-          warnGemini3xEffortNone(options.model);
+          warnGemini3xEffortNone(requestModel);
         }
-        generationConfig.thinkingConfig = { thinkingLevel: minThinkingLevel(options.model) };
+        generationConfig.thinkingConfig = { thinkingLevel: minThinkingLevel(requestModel) };
       } else {
         generationConfig.thinkingConfig = { thinkingBudget: 0 };
       }
       if (!body.generationConfig) body.generationConfig = generationConfig;
     } else if (hasBudgetOverride) {
       const config = {};
-      if (isGemini3x(options.model)) {
+      if (isGemini3x(requestModel)) {
         config.thinkingLevel = budgetToThinkingLevel(thinkingBudget);
       } else {
         config.thinkingBudget = thinkingBudget;
@@ -2542,10 +3463,10 @@ var GeminiProvider = class {
       if (!body.generationConfig) body.generationConfig = generationConfig;
     } else if (activeEffort) {
       const config = {};
-      if (isGemini3x(options.model)) {
+      if (isGemini3x(requestModel)) {
         config.thinkingLevel = THINKING_LEVELS[activeEffort] ?? "medium";
       } else {
-        if (activeEffort === "max" && options.model.startsWith("gemini-2.5-pro")) {
+        if (activeEffort === "max" && requestModel === "gemini-2.5-pro") {
           config.thinkingBudget = 32768;
         } else {
           config.thinkingBudget = THINKING_BUDGETS2[activeEffort] ?? 5e3;
@@ -2562,7 +3483,9 @@ var GeminiProvider = class {
       body.toolConfig = { functionCallingConfig: this.mapToolChoice(options.toolChoice) };
     }
     if (options.providerOptions) {
-      Object.assign(body, options.providerOptions);
+      const bodyOptions = { ...options.providerOptions };
+      delete bodyOptions.model;
+      Object.assign(body, bodyOptions);
     }
     return body;
   }
@@ -2580,6 +3503,7 @@ var GeminiProvider = class {
   mapMessages(messages) {
     const toolCallIdToName = /* @__PURE__ */ new Map();
     const geminiNativeIds = /* @__PURE__ */ new Set();
+    const geminiNativeNames = /* @__PURE__ */ new Map();
     for (const msg of messages) {
       if (msg.role === "assistant" && msg.tool_calls) {
         for (const tc of msg.tool_calls) {
@@ -2590,7 +3514,10 @@ var GeminiProvider = class {
         const rawParts = msg.providerMetadata?.geminiParts;
         if (rawParts) {
           for (const p of rawParts) {
-            if (p.functionCall?.id) geminiNativeIds.add(p.functionCall.id);
+            if (p.functionCall?.id) {
+              geminiNativeIds.add(p.functionCall.id);
+              geminiNativeNames.set(p.functionCall.id, p.functionCall.name);
+            }
           }
         }
       }
@@ -2627,7 +3554,7 @@ var GeminiProvider = class {
           }
         }
       } else if (msg.role === "tool") {
-        const functionName = toolCallIdToName.get(msg.tool_call_id) ?? "unknown";
+        const functionName = (msg.tool_call_id ? geminiNativeNames.get(msg.tool_call_id) : void 0) ?? toolCallIdToName.get(msg.tool_call_id) ?? "unknown";
         const functionResponse = {
           name: functionName,
           response: parseGeminiFunctionResponse(msg.content)
@@ -2692,7 +3619,7 @@ var GeminiProvider = class {
   // ---------------------------------------------------------------------------
   // Internal: response parsing
   // ---------------------------------------------------------------------------
-  parseResponse(json, model) {
+  parseResponse(json, pricingContext) {
     const candidate = json.candidates?.[0];
     let content = "";
     let thinkingContent = "";
@@ -2715,35 +3642,46 @@ var GeminiProvider = class {
         }
       }
     }
-    const cachedTokens = json.usageMetadata?.cachedContentTokenCount;
-    const reasoningTokens = json.usageMetadata?.thoughtsTokenCount;
-    const usage = json.usageMetadata ? {
-      prompt_tokens: json.usageMetadata.promptTokenCount ?? 0,
-      completion_tokens: json.usageMetadata.candidatesTokenCount ?? 0,
-      total_tokens: json.usageMetadata.totalTokenCount ?? 0,
-      cached_tokens: cachedTokens && cachedTokens > 0 ? cachedTokens : void 0,
-      reasoning_tokens: reasoningTokens && reasoningTokens > 0 ? reasoningTokens : void 0
-    } : void 0;
-    const cost = usage ? estimateGeminiCost(model, usage.prompt_tokens, usage.completion_tokens, usage.cached_tokens) : void 0;
+    if (!candidate) {
+      throw new Error("Gemini response did not include a candidate.");
+    }
+    if (candidate.finishReason && !["STOP", "MAX_TOKENS"].includes(candidate.finishReason)) {
+      throw new Error(`Gemini returned non-success finish reason: ${candidate.finishReason}`);
+    }
+    const normalized = json.usageMetadata ? normalizeGeminiUsage(json.usageMetadata) : void 0;
+    const effectiveModel = typeof json.modelVersion === "string" ? json.modelVersion : pricingContext.model;
+    const cost = normalized && !normalized.hasUnmodeledBilledUsage && this.isTextOnlyGeminiResponse(candidate) && isEligibleGeminiPricing(
+      pricingContext,
+      isDefinitiveStandardGeminiResponseTier(json.usageMetadata?.serviceTier),
+      json.usageMetadata?.serviceTier !== void 0 && !isDefinitiveStandardGeminiResponseTier(json.usageMetadata.serviceTier)
+    ) ? estimateGeminiCost(effectiveModel, normalized.pricingUsage) : void 0;
     const rawParts = candidate?.content?.parts;
     const providerMetadata = rawParts ? { geminiParts: rawParts } : void 0;
     return {
       content,
       thinking_content: thinkingContent || void 0,
       tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
-      usage,
+      usage: normalized?.usage,
       cost,
       providerMetadata
     };
   }
+  isTextOnlyGeminiResponse(candidate) {
+    return candidate?.content?.parts.every((part) => !this.isNonTextGeminiPart(part)) ?? false;
+  }
   // ---------------------------------------------------------------------------
   // Internal: SSE stream parsing
   // ---------------------------------------------------------------------------
-  async *parseSSEStream(body, model) {
+  async *parseSSEStream(body, pricingContext) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
-    let usage;
+    let normalizedUsage;
+    let effectiveModel = pricingContext.model;
+    let hasDefinitiveStandardResponseTier = false;
+    let hasInvalidResponseTier = false;
+    let responseIsTextOnly = true;
+    let terminalFailure;
     const accumulatedParts = [];
     try {
       while (true) {
@@ -2763,20 +3701,21 @@ var GeminiProvider = class {
           } catch {
             continue;
           }
+          if (typeof chunk.modelVersion === "string") effectiveModel = chunk.modelVersion;
           if (chunk.usageMetadata) {
-            const cached = chunk.usageMetadata.cachedContentTokenCount;
-            const reasoning = chunk.usageMetadata.thoughtsTokenCount;
-            usage = {
-              prompt_tokens: chunk.usageMetadata.promptTokenCount ?? 0,
-              completion_tokens: chunk.usageMetadata.candidatesTokenCount ?? 0,
-              total_tokens: chunk.usageMetadata.totalTokenCount ?? 0,
-              cached_tokens: cached && cached > 0 ? cached : void 0,
-              reasoning_tokens: reasoning && reasoning > 0 ? reasoning : void 0
-            };
+            normalizedUsage = normalizeGeminiUsage(chunk.usageMetadata);
+            if (chunk.usageMetadata.serviceTier !== void 0) {
+              if (isDefinitiveStandardGeminiResponseTier(chunk.usageMetadata.serviceTier)) {
+                hasDefinitiveStandardResponseTier = true;
+              } else {
+                hasInvalidResponseTier = true;
+              }
+            }
           }
           const candidate = chunk.candidates?.[0];
           if (candidate?.content?.parts) {
             for (const part of candidate.content.parts) {
+              if (this.isNonTextGeminiPart(part)) responseIsTextOnly = false;
               accumulatedParts.push(part);
               if (part.thought && part.text) {
                 yield { type: "thinking_delta", content: part.text };
@@ -2792,18 +3731,23 @@ var GeminiProvider = class {
               }
             }
           }
+          if (candidate?.finishReason && !["STOP", "MAX_TOKENS"].includes(candidate.finishReason)) {
+            terminalFailure = candidate.finishReason;
+          }
         }
       }
+      if (terminalFailure) {
+        throw new Error(`Gemini returned non-success finish reason: ${terminalFailure}`);
+      }
       const providerMetadata = accumulatedParts.length > 0 ? { geminiParts: accumulatedParts } : void 0;
       yield {
         type: "done",
-        usage,
-        cost: usage ? estimateGeminiCost(
-          model,
-          usage.prompt_tokens,
-          usage.completion_tokens,
-          usage.cached_tokens
-        ) : void 0,
+        usage: normalizedUsage?.usage,
+        cost: normalizedUsage && !normalizedUsage.hasUnmodeledBilledUsage && responseIsTextOnly && isEligibleGeminiPricing(
+          pricingContext,
+          hasDefinitiveStandardResponseTier,
+          hasInvalidResponseTier
+        ) ? estimateGeminiCost(effectiveModel, normalizedUsage.pricingUsage) : void 0,
         providerMetadata
       };
     } finally {
@@ -2820,8 +3764,6 @@ var OPENROUTER_PROFILE = {
   envApiKey: "OPENROUTER_API_KEY",
   envBaseUrl: "OPENROUTER_BASE_URL",
   pricing: { kind: "from-response" },
-  // Ask OpenRouter to report per-call cost in usage.cost.
-  requestDefaults: { usage: { include: true } },
   reasoning: {
     // OpenRouter's effort vocabulary is low|medium|high; xhigh/max clamp to high.
     emit: reasoningObjectEmit(
@@ -2844,7 +3786,7 @@ var AZURE_PROFILE = {
   envApiKey: "AZURE_OPENAI_API_KEY",
   envBaseUrl: "AZURE_OPENAI_BASE_URL",
   authHeader: "api-key",
-  pricing: { kind: "table", table: OPENAI_PRICING },
+  pricing: { kind: "unknown" },
   reasoning: { emit: openaiReasoningEmit, capture: "none" },
   roleFor: (role, model) => role === "system" && isOSeriesModel(model) ? "developer" : role,
   maxTokensField: "max_completion_tokens",
@@ -2852,29 +3794,100 @@ var AZURE_PROFILE = {
 };
 
 // src/providers/profiles/xai.ts
-var acceptsReasoningEffort = (model) => model.startsWith("grok-3-mini");
-var isReasoningModel = (model) => /^grok-(3-mini|4)/.test(model);
+var GROK_45 = /* @__PURE__ */ new Set(["grok-4.5", "grok-4.5-latest", "grok-build-latest"]);
+var GROK_43 = /* @__PURE__ */ new Set(["grok-4.3", "grok-4.3-latest", "grok-latest"]);
+var GROK_420_REASONING = /* @__PURE__ */ new Set([
+  "grok-4.20-0309-reasoning",
+  "grok-4.20-reasoning-latest",
+  "grok-4.20",
+  "grok-4.20-reasoning",
+  "grok-4.20-0309",
+  "grok-4.20-beta-0309-reasoning",
+  "grok-4.20-beta",
+  "grok-4.20-beta-0309",
+  "grok-4.20-beta-latest",
+  "grok-4.20-beta-latest-reasoning",
+  "grok-4.20-beta-reasoning",
+  "grok-4.20-experimental-beta-0304-reasoning",
+  "grok-4.20-experimental-beta-0304",
+  "grok-4.20-experimental-beta-reasoning-latest",
+  "grok-4.20-experimental-beta-latest",
+  "grok-4.20-reasoning-gv2"
+]);
+var GROK_420_NON_REASONING = /* @__PURE__ */ new Set([
+  "grok-4.20-0309-non-reasoning",
+  "grok-4.20-non-reasoning",
+  "grok-4.20-non-reasoning-latest",
+  "grok-4.20-beta-non-reasoning",
+  "grok-4.20-beta-latest-non-reasoning",
+  "grok-4.20-experimental-beta-0304-non-reasoning",
+  "grok-4.20-experimental-beta-non-reasoning-latest",
+  "grok-4.20-beta-0309-non-reasoning",
+  "grok-4.20-non-reasoning-gv2"
+]);
+var warnedIrreducible45 = /* @__PURE__ */ new Set();
+var warnedEffortClamp = /* @__PURE__ */ new Set();
+function warnIrreducible45(model) {
+  if (warnedIrreducible45.has(model)) return;
+  warnedIrreducible45.add(model);
+  console.warn(
+    `[axl] effort: 'none' on xAI ${model} maps to 'low'; Grok 4.5 cannot disable reasoning.`
+  );
+}
+function warnEffortClamp(model, effort) {
+  const key = `${model}:${effort}`;
+  if (warnedEffortClamp.has(key)) return;
+  warnedEffortClamp.add(key);
+  console.warn(
+    `[axl] effort: '${effort}' on xAI ${model} maps to 'high'; this model supports at most 'high'.`
+  );
+}
+var isReasoningChatModel = (model) => GROK_45.has(model) || GROK_43.has(model) || GROK_420_REASONING.has(model);
 var XAI_PROFILE = {
   name: "xai",
   label: "xAI",
   defaultBaseUrl: "https://api.x.ai/v1",
   envApiKey: "XAI_API_KEY",
   envBaseUrl: "XAI_BASE_URL",
-  pricing: { kind: "unknown" },
+  pricing: { kind: "from-response" },
   reasoning: {
     emit: reasoningEffortEmit((resolved, model) => {
-      if (!acceptsReasoningEffort(model)) return void 0;
-      if (resolved.thinkingDisabled || !resolved.activeEffort) return void 0;
-      return resolved.activeEffort === "low" ? "low" : "high";
+      if (GROK_45.has(model)) {
+        if (resolved.thinkingDisabled) {
+          warnIrreducible45(model);
+          return "low";
+        }
+        if (!resolved.activeEffort) return void 0;
+        if (resolved.activeEffort === "xhigh" || resolved.activeEffort === "max") {
+          warnEffortClamp(model, resolved.activeEffort);
+          return "high";
+        }
+        return resolved.activeEffort;
+      }
+      if (GROK_43.has(model)) {
+        if (resolved.thinkingDisabled) return "none";
+        if (!resolved.activeEffort) return void 0;
+        if (resolved.activeEffort === "xhigh" || resolved.activeEffort === "max") {
+          warnEffortClamp(model, resolved.activeEffort);
+          return "high";
+        }
+        return resolved.activeEffort;
+      }
+      if (GROK_420_NON_REASONING.has(model)) return void 0;
+      return void 0;
     }),
     capture: "reasoning"
   },
   capabilities: {
-    forbiddenParams: (model) => isReasoningModel(model) ? ["stop", "presence_penalty", "frequency_penalty"] : []
+    forbiddenParams: (model) => isReasoningChatModel(model) ? ["stop", "presence_penalty", "frequency_penalty"] : []
   }
 };
 
 // src/providers/profiles/deepseek.ts
+var DEEPSEEK_PRICING = {
+  "deepseek-v4-flash": [14e-8, 28e-8, 0.02],
+  "deepseek-v4-pro": [435e-9, 87e-8, 1 / 120]
+};
 var isReasoner = (model) => /reasoner|v4/i.test(model);
 var deepseekEmit = (_body, _resolved, model) => ({
   stripTemperature: isReasoner(model)
@@ -2885,7 +3898,7 @@ var DEEPSEEK_PROFILE = {
   defaultBaseUrl: "https://api.deepseek.com/v1",
   envApiKey: "DEEPSEEK_API_KEY",
   envBaseUrl: "DEEPSEEK_BASE_URL",
-  pricing: { kind: "unknown" },
+  pricing: { kind: "table", table: DEEPSEEK_PRICING, match: "exact" },
   reasoning: {
     emit: deepseekEmit,
     capture: "reasoning_content",
@@ -2896,27 +3909,56 @@ var DEEPSEEK_PROFILE = {
     forbiddenParams: (model) => isReasoner(model) ? ["top_p", "presence_penalty", "frequency_penalty"] : []
   }
 };
+attachBuiltinTablePricingPolicy(DEEPSEEK_PROFILE, {
+  canonicalBaseUrl: "https://api.deepseek.com/v1",
+  requireCacheSplit: true
+});
 
 // src/providers/profiles/mistral.ts
-var acceptsReasoningEffort2 = (model) => /^mistral-(small|medium)/i.test(model);
+var MISTRAL_PRICING = {
+  "mistral-medium-latest": [15e-7, 75e-7, 0.1],
+  "mistral-small-latest": [15e-8, 6e-7, 0.1],
+  "mistral-large-latest": [5e-7, 15e-7, 0.1],
+  "devstral-medium-latest": [4e-7, 2e-6, 0.1],
+  "devstral-small-latest": [1e-7, 3e-7, 0.1],
+  "codestral-latest": [3e-7, 9e-7, 0.1],
+  "magistral-medium-latest": [2e-6, 5e-6, 0.1],
+  "magistral-small-latest": [5e-7, 15e-7, 0.1],
+  "ministral-3b-latest": [1e-7, 1e-7, 0.1],
+  "ministral-8b-latest": [15e-8, 15e-8, 0.1],
+  "ministral-14b-latest": [2e-7, 2e-7, 0.1],
+  "open-mistral-nemo": [15e-8, 15e-8, 0.1],
+  "open-mixtral-8x7b": [7e-7, 7e-7, 0.1],
+  "open-mixtral-8x22b": [2e-6, 6e-6, 0.1]
+};
+var acceptsReasoningEffort = (model) => /^mistral-(small|medium)/i.test(model);
 var MISTRAL_PROFILE = {
   name: "mistral",
   label: "Mistral",
   defaultBaseUrl: "https://api.mistral.ai/v1",
   envApiKey: "MISTRAL_API_KEY",
   envBaseUrl: "MISTRAL_BASE_URL",
-  pricing: { kind: "unknown" },
+  pricing: { kind: "table", table: MISTRAL_PRICING, match: "exact" },
   reasoning: {
     emit: reasoningEffortEmit((resolved, model) => {
-      if (!acceptsReasoningEffort2(model)) return void 0;
+      if (!acceptsReasoningEffort(model)) return void 0;
       if (resolved.thinkingDisabled || !resolved.activeEffort) return void 0;
       return "high";
     }),
     capture: "reasoning_content"
   }
 };
+attachBuiltinTablePricingPolicy(MISTRAL_PROFILE, {
+  canonicalBaseUrl: "https://api.mistral.ai/v1"
+});
 
 // src/providers/profiles/groq.ts
+var GROQ_PRICING = {
+  "llama-3.1-8b-instant": [5e-8, 8e-8, 1],
+  "llama-3.3-70b-versatile": [59e-8, 79e-8, 1],
+  "openai/gpt-oss-120b": [15e-8, 6e-7, 0.5],
+  "openai/gpt-oss-20b": [75e-9, 3e-7, 0.5]
+};
 var isGptOss = (model) => /gpt-oss/i.test(model);
 var GROQ_PROFILE = {
   name: "groq",
@@ -2924,7 +3966,11 @@ var GROQ_PROFILE = {
   defaultBaseUrl: "https://api.groq.com/openai/v1",
   envApiKey: "GROQ_API_KEY",
   envBaseUrl: "GROQ_BASE_URL",
-  pricing: { kind: "unknown" },
+  pricing: {
+    kind: "table",
+    table: GROQ_PRICING,
+    match: "exact"
+  },
   reasoning: {
     emit: reasoningEffortEmit((resolved, model) => {
       if (!isGptOss(model) || resolved.thinkingDisabled || !resolved.activeEffort) {
@@ -2945,6 +3991,21 @@ var GROQ_PROFILE = {
     supportsJsonSchema: isGptOss
   }
 };
+attachBuiltinTablePricingPolicy(GROQ_PROFILE, {
+  canonicalBaseUrl: "https://api.groq.com/openai/v1",
+  supportedServiceTiers: ["on_demand", "flex"],
+  functionToolsOnly: true,
+  chargedRequestModifiers: [
+    "browser_search",
+    "code_interpreter",
+    "web_search",
+    "visit_website",
+    "wolfram_alpha",
+    "remote_mcp",
+    "mcp",
+    "compound_custom"
+  ]
+});
 
 // src/providers/profiles/bedrock.ts
 var isGptOss2 = (model) => /gpt-oss/i.test(model);
@@ -3759,7 +4820,7 @@ var COST_LEAF_SET = new Set(COST_BEARING_LEAF_TYPES);
 function hasPositiveTokens(event) {
   const t = event.tokens;
   if (!t) return false;
-  return (t.input ?? 0) + (t.output ?? 0) + (t.reasoning ?? 0) > 0;
+  return (t.input ?? 0) + (t.output ?? 0) + (t.reasoning ?? 0) + (t.cached ?? 0) + (t.cacheWrite ?? 0) > 0;
 }
 function isUsableCost(cost) {
   return typeof cost === "number" && Number.isFinite(cost) && cost >= 0;
@@ -6372,6 +7433,11 @@ var WorkflowContext = class _WorkflowContext {
                       "axl.agent.cached_tokens",
                       usageCapture.value.cached_tokens
                     );
+                  if (usageCapture.value.cache_write_tokens)
+                    span.setAttribute(
+                      "axl.agent.cache_write_tokens",
+                      usageCapture.value.cache_write_tokens
+                    );
                 }
                 return r;
               }
@@ -6817,7 +7883,9 @@ ${appendedSchemaText}`;
         tokens: response.usage ? {
           input: response.usage.prompt_tokens,
           output: response.usage.completion_tokens,
-          reasoning: response.usage.reasoning_tokens
+          reasoning: response.usage.reasoning_tokens,
+          cached: response.usage.cached_tokens,
+          cacheWrite: response.usage.cache_write_tokens
         } : void 0,
         duration: Date.now() - turnStart,
         data: {