@genesislcap/foundation-ai 14.469.0 → 14.470.0

package/dist/esm/transports/anthropic-transport.js

@@ -57,6 +57,53 @@ function estimatedAnthropicRatesUsdPerMillion(model) {
     // Opus 4.7
     return { promptPerMillion: 5, candidatePerMillion: 25 };
 }
+/**
+ * Prompt-cache pricing multipliers, applied to the model's base input rate
+ * (`promptPerMillion`) — https://docs.claude.com/en/docs/build-with-claude/prompt-caching
+ * Reads bill at ~0.1× base input; writes bill by TTL — 5-minute at ~1.25× and 1-hour at 2×.
+ * Both write TTLs are reachable (`CachePolicy.ttl` is `'5m' | '1h'` and `applyCacheControl`
+ * emits either), so the cost path costs each TTL bucket from the response's per-TTL
+ * `cache_creation` breakdown rather than assuming a single rate.
+ */
+const ANTHROPIC_CACHE_READ_MULTIPLIER = 0.1;
+const ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER = 1.25;
+const ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER = 2;
+/**
+ * Thrown when a response stops at `stop_reason: 'max_tokens'` while it still
+ * carries tool calls. The model ran out of its output-token budget mid-stream,
+ * so the truncated tool call's argument JSON was cut off before it closed — the
+ * arguments are incomplete and the call is unusable (e.g. a `vfs_write` whose
+ * `content` never finished serializing). Rather than hand a corrupt tool call to
+ * the caller — which silently runs with missing args and tends to be retried into
+ * an identical wall — the transport raises this so the failure is loud and
+ * diagnosable.
+ *
+ * It is deterministic: re-issuing the same request hits the same cap. The remedy
+ * is to raise the provider's `maxTokens` (see {@link AnthropicAIConfig.maxTokens})
+ * or to split the work into smaller outputs — not to retry verbatim.
+ *
+ * @beta
+ */
+export class ResponseTruncatedError extends Error {
+    constructor(
+    /** The model that produced the truncated response. */
+    model, 
+    /** The `max_tokens` cap the request was sent with. */
+    maxTokens, 
+    /** Output tokens generated before truncation, when the usage block is present. */
+    outputTokens, 
+    /** Names of the tool call(s) on the truncated turn (the last is the cut-off one). */
+    toolNames) {
+        super(`Anthropic response truncated at the max_tokens cap (${maxTokens}) for model ${model}` +
+            (toolNames.length > 0 ? ` while emitting tool call(s): ${toolNames.join(', ')}` : '') +
+            '. The output exceeds the per-response limit — raise the provider maxTokens or split the work into smaller outputs.');
+        this.model = model;
+        this.maxTokens = maxTokens;
+        this.outputTokens = outputTokens;
+        this.toolNames = toolNames;
+        this.name = 'ResponseTruncatedError';
+    }
+}
 /**
  * Transport for Anthropic Claude. Calls the Messages API directly when `apiKey`
  * is provided, otherwise falls back to a server-proxy endpoint (if `serverEndpoint`
@@ -77,6 +124,12 @@ export class AnthropicTransport {
          * fields instead so its session total stays attributed to chat turns only.
          */
         this.lifetimeCostUsd = 0;
+        /**
+         * Estimated USD saved by prompt caching vs paying full input price, accumulated across
+         * every request. Net of cache-write premiums, so it can be briefly negative before reads
+         * accrue. Surfaced alongside `getLifetimeCost`.
+         */
+        this.lifetimeSavingsUsd = 0;
         const model = (_a = config.model) !== null && _a !== void 0 ? _a : DEFAULT_MODEL;
         assertSupportedAnthropicModel(model);
         this.model = model;
@@ -102,9 +155,14 @@ export class AnthropicTransport {
     getLifetimeCost() {
         return this.lifetimeCostUsd;
     }
-    /** Reset the lifetime cost counter. Intended for chat-clear / new-session flows. */
+    /** Estimated USD saved by prompt caching (net of write premiums) across this instance. */
+    getLifetimeSavings() {
+        return this.lifetimeSavingsUsd;
+    }
+    /** Reset the lifetime cost + savings counters. Intended for chat-clear / new-session flows. */
     resetLifetimeCost() {
         this.lifetimeCostUsd = 0;
+        this.lifetimeSavingsUsd = 0;
     }
     // ── AITransport (structured prompt) ────────────────────────────────────
     sendStructuredPrompt(options) {
@@ -185,26 +243,116 @@ export class AnthropicTransport {
                     maxTemp: ANTHROPIC_MAX_TEMPERATURE,
                 });
             }
+            // Place prompt-cache breakpoints per the resolved policy (no-op for `'default'`/absent).
+            if (options === null || options === void 0 ? void 0 : options.cachePolicy) {
+                this.applyCacheControl(body, options.cachePolicy);
+            }
+            // Inject never-stored tail context AFTER the cache breakpoints, so this per-turn volatile
+            // block stays outside the cached prefix. The caller has already framed it.
+            if (options === null || options === void 0 ? void 0 : options.tailContext) {
+                this.appendTailContext(body, options.tailContext);
+            }
             const response = yield this.post(body, options === null || options === void 0 ? void 0 : options.signal);
             return this.fromAnthropicResponse(response);
         });
     }
+    /**
+     * Place prompt-cache breakpoints on the outgoing request per the resolved {@link CachePolicy}.
+     * A breakpoint is `cache_control: {type:'ephemeral'}` on a content block / tool / system block;
+     * the API caches the byte-exact prefix up to it. Below a model's minimum cacheable prefix the
+     * marker is silently ignored (no error), so placing one is always safe.
+     *
+     * Render order is tools → system → messages, so a breakpoint's cached prefix covers everything
+     * before it:
+     * - `'tools'`   — last tool (caches the tool block; survives a later system-prompt change).
+     * - `'prompt'`  — system block (caches tools + system); falls back to the last tool when there
+     *   is no system prompt.
+     * - `'history'` — last stored message block (caches tools + system + the whole stored history),
+     *   keeping the system-tier breakpoint as a cheaper fallback. The injected, never-stored tail
+     *   context (if any) sits after this and is intentionally left uncached.
+     */
+    applyCacheControl(body, policy) {
+        var _a, _b;
+        if (policy.scope === 'default')
+            return;
+        const cacheControl = policy.ttl === '1h' ? { type: 'ephemeral', ttl: '1h' } : { type: 'ephemeral' };
+        if (policy.scope === 'tools') {
+            if ((_a = body.tools) === null || _a === void 0 ? void 0 : _a.length) {
+                body.tools[body.tools.length - 1].cache_control = cacheControl;
+            }
+            return;
+        }
+        // 'prompt' and 'history' both cache through the system prompt. A breakpoint on the (single)
+        // system block caches tools + system together; with no system prompt, fall back to the last
+        // tool — the furthest stable prefix available.
+        if (typeof body.system === 'string' && body.system.length > 0) {
+            body.system = [{ type: 'text', text: body.system, cache_control: cacheControl }];
+        }
+        else if ((_b = body.tools) === null || _b === void 0 ? void 0 : _b.length) {
+            body.tools[body.tools.length - 1].cache_control = cacheControl;
+        }
+        if (policy.scope === 'history') {
+            const lastMessage = body.messages[body.messages.length - 1];
+            if (lastMessage && Array.isArray(lastMessage.content) && lastMessage.content.length > 0) {
+                lastMessage.content[lastMessage.content.length - 1].cache_control = cacheControl;
+            }
+        }
+    }
+    /**
+     * Append never-stored tail context (already framed by the caller) as the final block of the
+     * outbound messages. Called AFTER `applyCacheControl`, so any `'history'` breakpoint sits
+     * on the last *stored* block and this per-turn volatile block stays outside the cached prefix.
+     * At a model-call the last message is user-role; if not (defensive), start a fresh user turn.
+     */
+    appendTailContext(body, tailContext) {
+        const block = { type: 'text', text: tailContext };
+        const lastMessage = body.messages[body.messages.length - 1];
+        if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.role) === 'user' && Array.isArray(lastMessage.content)) {
+            lastMessage.content.push(block);
+        }
+        else {
+            body.messages.push({ role: 'user', content: [block] });
+        }
+    }
     /**
      * Logs the per-call cost breakdown, accumulates the lifetime running total,
      * and returns the per-call total so the caller can attach it to the response
      * message.
      */
-    logTokenUsage(promptTokens, candidateTokens) {
+    logTokenUsage(promptTokens, candidateTokens, cacheReadTokens, cacheCreationTokens, cacheCreation1hTokens) {
         const { promptPerMillion, candidatePerMillion } = estimatedAnthropicRatesUsdPerMillion(this.model);
-        const promptCost = (promptTokens / AnthropicTransport.TOKENS_PER_MILLION) * promptPerMillion;
-        const candidateCost = (candidateTokens / AnthropicTransport.TOKENS_PER_MILLION) * candidatePerMillion;
-        const totalCost = promptCost + candidateCost;
+        const m = AnthropicTransport.TOKENS_PER_MILLION;
+        // `promptTokens` is `input_tokens` — the UNCACHED remainder, billed at the full input
+        // rate. Cache reads bill at ~0.1×. Cache writes bill by TTL — 5-min at ~1.25×, 1-hour at
+        // 2× — so split the creation total into its 1-hour portion (from the response breakdown)
+        // and the 5-min remainder, costing each at its own rate. All buckets are off the same base
+        // input rate. Summing them keeps the cost correct whether or not caching was active (all
+        // cache fields are 0 when it wasn't).
+        const cacheCreation5mTokens = Math.max(0, cacheCreationTokens - cacheCreation1hTokens);
+        const promptCost = (promptTokens / m) * promptPerMillion;
+        const cacheReadCost = (cacheReadTokens / m) * promptPerMillion * ANTHROPIC_CACHE_READ_MULTIPLIER;
+        const cacheWriteCost = (cacheCreation5mTokens / m) * promptPerMillion * ANTHROPIC_CACHE_WRITE_5M_MULTIPLIER +
+            (cacheCreation1hTokens / m) * promptPerMillion * ANTHROPIC_CACHE_WRITE_1H_MULTIPLIER;
+        const candidateCost = (candidateTokens / m) * candidatePerMillion;
+        const totalCost = promptCost + cacheReadCost + cacheWriteCost + candidateCost;
         this.lifetimeCostUsd += totalCost;
+        // Net savings vs no caching: the cache-read tokens would have cost full input price
+        // (we paid ~0.1× of that), while the write premium (~0.25× over full) is an upfront cost
+        // that pays back on later reads — so the net can dip negative on a write-heavy request and
+        // climb positive as reads accrue. Zero when caching was inactive.
+        const cacheReadFull = (cacheReadTokens / m) * promptPerMillion;
+        const cacheWriteFull = (cacheCreationTokens / m) * promptPerMillion;
+        const saved = cacheReadFull - cacheReadCost + (cacheWriteFull - cacheWriteCost);
+        this.lifetimeSavingsUsd += saved;
+        const dp = AnthropicTransport.COST_DECIMAL_PLACES;
         console.log(`--- Anthropic Token Usage (${this.model}) ---`);
-        console.log(`Prompt Tokens:    ${promptTokens} ($${promptCost.toFixed(AnthropicTransport.COST_DECIMAL_PLACES)})`);
-        console.log(`Candidate Tokens: ${candidateTokens} ($${candidateCost.toFixed(AnthropicTransport.COST_DECIMAL_PLACES)})`);
-        console.log(`Total Cost:       $${totalCost.toFixed(AnthropicTransport.COST_DECIMAL_PLACES)}`);
-        console.log(`Lifetime Cost:    $${this.lifetimeCostUsd.toFixed(AnthropicTransport.COST_DECIMAL_PLACES)}`);
+        console.log(`Prompt Tokens:    ${promptTokens} ($${promptCost.toFixed(dp)})`);
+        console.log(`Cache Read:       ${cacheReadTokens} ($${cacheReadCost.toFixed(dp)})`);
+        console.log(`Cache Write:      ${cacheCreationTokens} ($${cacheWriteCost.toFixed(dp)})`);
+        console.log(`Candidate Tokens: ${candidateTokens} ($${candidateCost.toFixed(dp)})`);
+        console.log(`Total Cost:       $${totalCost.toFixed(dp)}`);
+        console.log(`Cache Saved:      $${saved.toFixed(dp)} (lifetime $${this.lifetimeSavingsUsd.toFixed(dp)})`);
+        console.log(`Lifetime Cost:    $${this.lifetimeCostUsd.toFixed(dp)}`);
         console.log('--------------------------');
         return totalCost;
     }
@@ -278,20 +426,30 @@ export class AnthropicTransport {
         return messages;
     }
     fromAnthropicResponse(response) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         let inputTokens;
         let outputTokens;
         let cost;
         if (response.usage) {
-            cost = this.logTokenUsage((_a = response.usage.input_tokens) !== null && _a !== void 0 ? _a : 0, (_b = response.usage.output_tokens) !== null && _b !== void 0 ? _b : 0);
-            if (response.usage.input_tokens != null) {
-                inputTokens = response.usage.input_tokens;
-            }
+            const uncachedInput = (_a = response.usage.input_tokens) !== null && _a !== void 0 ? _a : 0;
+            const cacheRead = (_b = response.usage.cache_read_input_tokens) !== null && _b !== void 0 ? _b : 0;
+            // 1-hour writes bill at 2× vs 1.25× for 5-min, so read the per-TTL breakdown when present
+            // and let the cost path split the buckets. Fall back to the flat total (treated as 5-min)
+            // when the breakdown is absent.
+            const breakdown = response.usage.cache_creation;
+            const cacheCreation1h = (_c = breakdown === null || breakdown === void 0 ? void 0 : breakdown.ephemeral_1h_input_tokens) !== null && _c !== void 0 ? _c : 0;
+            const cacheCreation = (_d = response.usage.cache_creation_input_tokens) !== null && _d !== void 0 ? _d : (breakdown ? ((_e = breakdown.ephemeral_5m_input_tokens) !== null && _e !== void 0 ? _e : 0) + cacheCreation1h : 0);
+            cost = this.logTokenUsage(uncachedInput, (_f = response.usage.output_tokens) !== null && _f !== void 0 ? _f : 0, cacheRead, cacheCreation, cacheCreation1h);
+            // Report TOTAL prompt size (uncached + cache read + cache write) so `inputTokens` means
+            // "prompt tokens" consistently whether or not caching was active — matching Gemini's
+            // `promptTokenCount`, which already includes cached tokens. Cost (above) reflects the
+            // cache discount; this field is the size, not the bill.
+            inputTokens = uncachedInput + cacheRead + cacheCreation;
             if (response.usage.output_tokens != null) {
                 outputTokens = response.usage.output_tokens;
             }
         }
-        const blocks = (_c = response.content) !== null && _c !== void 0 ? _c : [];
+        const blocks = (_g = response.content) !== null && _g !== void 0 ? _g : [];
         const toolCalls = [];
         const thoughtParts = [];
         const textParts = [];
@@ -300,7 +458,7 @@ export class AnthropicTransport {
                 toolCalls.push({
                     id: block.id,
                     name: block.name,
-                    args: (_d = block.input) !== null && _d !== void 0 ? _d : {},
+                    args: (_h = block.input) !== null && _h !== void 0 ? _h : {},
                 });
             }
             else if (block.type === 'thinking') {
@@ -310,6 +468,15 @@ export class AnthropicTransport {
                 textParts.push(block.text);
             }
         }
+        // A `max_tokens` stop means the response was cut off mid-stream. For a turn
+        // carrying tool calls this is fatal: the final tool call's argument JSON was
+        // truncated before it closed, so its args are incomplete and the call cannot
+        // be run. Raise rather than return a corrupt tool call (which would run with
+        // missing args and get retried into the same wall). Usage/cost is already
+        // logged above, so the spent tokens are still accounted for on this instance.
+        if (response.stop_reason === 'max_tokens' && toolCalls.length > 0) {
+            throw new ResponseTruncatedError(this.model, this.maxTokens, outputTokens, toolCalls.map((tc) => tc.name));
+        }
         const base = toolCalls.length > 0
             ? {
                 role: 'assistant',
@@ -323,6 +490,13 @@ export class AnthropicTransport {
             base.outputTokens = outputTokens;
         if (cost != null)
             base.cost = cost;
+        // Surface a non-standard stop reason for observability and parity with the
+        // Gemini transport's `responseMeta.finishReason`. A text-only `max_tokens`
+        // stop yields partial-but-legible content, so it is returned (not raised) with
+        // the truncation flagged — the caller can decide what to do with it.
+        if (response.stop_reason === 'max_tokens') {
+            base.responseMeta = { finishReason: 'max_tokens' };
+        }
         return base;
     }
     buildEndpoint() {

package/dist/esm/transports/gemini-transport.js

@@ -46,6 +46,14 @@ function assertSupportedGeminiModel(model) {
  * to the whole request based on prompt size — it is not a marginal/blended rate.
  */
 const GEMINI_LONG_CONTEXT_THRESHOLD = 200000;
+/**
+ * Cached / context-cache input tokens bill at a flat ~10% of the model's normal input
+ * rate — consistent across models (flash $0.30→$0.03, flash-lite $0.10→$0.01,
+ * pro $1.25→$0.125). Source: https://ai.google.dev/gemini-api/docs/pricing.
+ * (Explicit context caching also has an hourly storage fee; implicit caching — what we
+ * rely on — has none, so only this read discount applies.)
+ */
+const GEMINI_CACHED_INPUT_MULTIPLIER = 0.1;
 /**
  * Paid Standard tier rates (USD per million tokens) — https://ai.google.dev/gemini-api/docs/pricing
  */
@@ -141,6 +149,12 @@ export class GeminiTransport {
          * fields instead so its session total stays attributed to chat turns only.
          */
         this.lifetimeCostUsd = 0;
+        /**
+         * Estimated USD saved by context caching vs paying full input price, accumulated across
+         * every request. Gemini implicit caching has no write premium, so this is always ≥ 0.
+         * Surfaced alongside `getLifetimeCost`.
+         */
+        this.lifetimeSavingsUsd = 0;
         const model = (_a = config.model) !== null && _a !== void 0 ? _a : DEFAULT_MODEL;
         assertSupportedGeminiModel(model);
         this.model = model;
@@ -163,9 +177,14 @@ export class GeminiTransport {
     getLifetimeCost() {
         return this.lifetimeCostUsd;
     }
-    /** Reset the lifetime cost counter. Intended for chat-clear / new-session flows. */
+    /** Estimated USD saved by context caching across this instance (implicit caching → always ≥ 0). */
+    getLifetimeSavings() {
+        return this.lifetimeSavingsUsd;
+    }
+    /** Reset the lifetime cost + savings counters. Intended for chat-clear / new-session flows. */
     resetLifetimeCost() {
         this.lifetimeCostUsd = 0;
+        this.lifetimeSavingsUsd = 0;
     }
     // ── AITransport (structured prompt) ────────────────────────────────────
     sendStructuredPrompt(options) {
@@ -186,7 +205,18 @@ export class GeminiTransport {
     sendChatMessage(history, userMessage, options) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
+            // NOTE: `options.cachePolicy` is intentionally NOT read here. Gemini 2.5+ does *implicit*
+            // caching automatically and always-on — it caches as much of the stable request prefix as it
+            // can on every call, regardless of the policy's `scope` (including `'default'`). We issue no
+            // explicit `cachedContent`, so there is no request-side field to set; the only lever is
+            // keeping the prefix byte-stable (a consumer concern). The cached tokens that come back are
+            // priced in `logTokenUsage` via `cachedContentTokenCount`. See `CachePolicy` docs.
             const contents = this.toGeminiContents(history, userMessage, options === null || options === void 0 ? void 0 : options.attachments);
+            // Never-stored tail context as a trailing user content (after the stable prefix). Verified
+            // valid even directly after a functionResponse content. The caller has already framed it.
+            if (options === null || options === void 0 ? void 0 : options.tailContext) {
+                contents.push({ role: 'user', parts: [{ text: options.tailContext }] });
+            }
             const tools = ((_a = options === null || options === void 0 ? void 0 : options.tools) === null || _a === void 0 ? void 0 : _a.length)
                 ? [
                     {
@@ -234,21 +264,33 @@ export class GeminiTransport {
      * and returns the per-call total so the caller can attach it to the response
      * message.
      */
-    logTokenUsage(promptTokens, candidateTokens, thoughtTokens) {
+    logTokenUsage(promptTokens, candidateTokens, thoughtTokens, cachedTokens) {
         const { promptPerMillion, candidatePerMillion } = estimatedGeminiPaidRatesUsdPerMillion(this.model, promptTokens);
-        const promptCost = (promptTokens / GeminiTransport.TOKENS_PER_MILLION) * promptPerMillion;
+        const m = GeminiTransport.TOKENS_PER_MILLION;
+        // `promptTokenCount` INCLUDES the cached portion (opposite of Anthropic's `input_tokens`),
+        // so split it: the uncached remainder bills at the full input rate and the cached slice at
+        // ~0.1×. The pricing TIER is still chosen on the full prompt size (above). `cachedTokens`
+        // is 0 when caching wasn't active, so this is a no-op then.
+        const uncachedPromptTokens = Math.max(0, promptTokens - cachedTokens);
+        const promptCost = (uncachedPromptTokens / m) * promptPerMillion;
+        const cacheReadCost = (cachedTokens / m) * promptPerMillion * GEMINI_CACHED_INPUT_MULTIPLIER;
         // Thinking tokens are billed at the output (candidate) rate. They are
         // incurred whenever the model thinks (always, on 2.5 Pro) — counting them
         // here corrects a long-standing undercount, it does not raise the bill.
-        const candidateCost = ((candidateTokens + thoughtTokens) / GeminiTransport.TOKENS_PER_MILLION) *
-            candidatePerMillion;
-        const totalCost = promptCost + candidateCost;
+        const candidateCost = ((candidateTokens + thoughtTokens) / m) * candidatePerMillion;
+        const totalCost = promptCost + cacheReadCost + candidateCost;
         this.lifetimeCostUsd += totalCost;
+        // Savings vs no caching: the cached tokens would have cost full input price; we paid ~0.1×.
+        // Implicit caching has no write premium, so this is always ≥ 0.
+        const saved = (cachedTokens / m) * promptPerMillion - cacheReadCost;
+        this.lifetimeSavingsUsd += saved;
+        const dp = GeminiTransport.COST_DECIMAL_PLACES;
         console.log(`--- Gemini Token Usage (${this.model}) ---`);
-        console.log(`Prompt Tokens:    ${promptTokens} ($${promptCost.toFixed(GeminiTransport.COST_DECIMAL_PLACES)})`);
-        console.log(`Candidate Tokens: ${candidateTokens} (+${thoughtTokens} thinking) ($${candidateCost.toFixed(GeminiTransport.COST_DECIMAL_PLACES)})`);
-        console.log(`Total Cost:       $${totalCost.toFixed(GeminiTransport.COST_DECIMAL_PLACES)}`);
-        console.log(`Lifetime Cost:    $${this.lifetimeCostUsd.toFixed(GeminiTransport.COST_DECIMAL_PLACES)}`);
+        console.log(`Prompt Tokens:    ${promptTokens} (${cachedTokens} cached) ($${promptCost.toFixed(dp)} + $${cacheReadCost.toFixed(dp)})`);
+        console.log(`Candidate Tokens: ${candidateTokens} (+${thoughtTokens} thinking) ($${candidateCost.toFixed(dp)})`);
+        console.log(`Total Cost:       $${totalCost.toFixed(dp)}`);
+        console.log(`Cache Saved:      $${saved.toFixed(dp)} (lifetime $${this.lifetimeSavingsUsd.toFixed(dp)})`);
+        console.log(`Lifetime Cost:    $${this.lifetimeCostUsd.toFixed(dp)}`);
         console.log('--------------------------');
         return totalCost;
     }
@@ -325,14 +367,14 @@ export class GeminiTransport {
         return contents;
     }
     fromGeminiResponse(response, offeredToolNames = new Set()) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         let inputTokens;
         let outputTokens;
         let thoughtsTokens;
         let cost;
         if (response.usageMetadata) {
             const usage = response.usageMetadata;
-            cost = this.logTokenUsage((_a = usage.promptTokenCount) !== null && _a !== void 0 ? _a : 0, (_b = usage.candidatesTokenCount) !== null && _b !== void 0 ? _b : 0, (_c = usage.thoughtsTokenCount) !== null && _c !== void 0 ? _c : 0);
+            cost = this.logTokenUsage((_a = usage.promptTokenCount) !== null && _a !== void 0 ? _a : 0, (_b = usage.candidatesTokenCount) !== null && _b !== void 0 ? _b : 0, (_c = usage.thoughtsTokenCount) !== null && _c !== void 0 ? _c : 0, (_d = usage.cachedContentTokenCount) !== null && _d !== void 0 ? _d : 0);
             if (usage.promptTokenCount != null) {
                 inputTokens = usage.promptTokenCount;
             }
@@ -344,12 +386,12 @@ export class GeminiTransport {
                 // reported in a field disjoint from `candidatesTokenCount`. Fold them into
                 // the provider-agnostic `outputTokens` so it reflects the true generated
                 // total — matching Anthropic, whose `output_tokens` already includes them.
-                outputTokens = ((_d = usage.candidatesTokenCount) !== null && _d !== void 0 ? _d : 0) + ((_e = usage.thoughtsTokenCount) !== null && _e !== void 0 ? _e : 0);
+                outputTokens = ((_e = usage.candidatesTokenCount) !== null && _e !== void 0 ? _e : 0) + ((_f = usage.thoughtsTokenCount) !== null && _f !== void 0 ? _f : 0);
             }
         }
         const candidates = response === null || response === void 0 ? void 0 : response.candidates;
         const firstCandidate = candidates === null || candidates === void 0 ? void 0 : candidates[0];
-        const parts = (_g = (_f = firstCandidate === null || firstCandidate === void 0 ? void 0 : firstCandidate.content) === null || _f === void 0 ? void 0 : _f.parts) !== null && _g !== void 0 ? _g : [];
+        const parts = (_h = (_g = firstCandidate === null || firstCandidate === void 0 ? void 0 : firstCandidate.content) === null || _g === void 0 ? void 0 : _g.parts) !== null && _h !== void 0 ? _h : [];
         const toolCalls = [];
         const thoughtParts = [];
         const textParts = [];
@@ -366,7 +408,7 @@ export class GeminiTransport {
                 toolCalls.push({
                     id: crypto.randomUUID(),
                     name: part.functionCall.name,
-                    args: (_h = part.functionCall.args) !== null && _h !== void 0 ? _h : {},
+                    args: (_j = part.functionCall.args) !== null && _j !== void 0 ? _j : {},
                     providerMetadata: { [GEMINI_PROVIDER_KEY]: state },
                 });
             }
@@ -430,7 +472,7 @@ export class GeminiTransport {
         // Surface the provider diagnostic on the message so the driver can fold it
         // into the debug-log meta events (the console log above is dev-only). Only
         // when there's signal — a finish reason, thinking tokens, or a block reason.
-        const blockReason = (_j = response.promptFeedback) === null || _j === void 0 ? void 0 : _j.blockReason;
+        const blockReason = (_k = response.promptFeedback) === null || _k === void 0 ? void 0 : _k.blockReason;
         if (finishReason != null || thoughtsTokens != null || blockReason != null) {
             base.responseMeta = {
                 finishReason,