@link-assistant/hive-mind 2.0.8 → 2.0.9

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 2.0.9
+
+### Patch Changes
+
+- c8b241a: Fix Claude public cost estimates for 1-hour prompt-cache writes by pricing `cache_creation.ephemeral_1h_input_tokens` at the documented 2x input rate instead of the 5-minute cache-write rate.
+
 ## 2.0.8
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.0.8",
+  "version": "2.0.9",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/claude.budget-stats.lib.mjs

@@ -111,17 +111,27 @@ export const displayModelUsage = async (usage, log) => {
     await log('');
     await log('      Cost Calculation (USD):');
     const breakdown = usage.costBreakdown;
-    const types = [
-      { key: 'input', label: 'Input' },
-      { key: 'cacheWrite', label: 'Cache write' },
-      { key: 'cacheRead', label: 'Cache read' },
-      { key: 'output', label: 'Output' },
-    ];
-    for (const { key, label } of types) {
-      if (breakdown[key].tokens > 0) {
-        await log(`        ${label}: ${formatNumber(breakdown[key].tokens)} tokens × $${breakdown[key].costPerMillion}/M = $${new Decimal(breakdown[key].cost).toFixed(6)}`);
+    if (breakdown.input.tokens > 0) {
+      await log(`        Input: ${formatNumber(breakdown.input.tokens)} tokens × $${breakdown.input.costPerMillion}/M = $${new Decimal(breakdown.input.cost).toFixed(6)}`);
+    }
+    if (breakdown.cacheWrite?.tokens > 0) {
+      if (breakdown.cacheWrite.hasExplicitTtlSplit) {
+        if (breakdown.cacheWrite5m.tokens > 0) {
+          await log(`        Cache write (5m): ${formatNumber(breakdown.cacheWrite5m.tokens)} tokens × $${breakdown.cacheWrite5m.costPerMillion}/M = $${new Decimal(breakdown.cacheWrite5m.cost).toFixed(6)}`);
+        }
+        if (breakdown.cacheWrite1h.tokens > 0) {
+          await log(`        Cache write (1h): ${formatNumber(breakdown.cacheWrite1h.tokens)} tokens × $${breakdown.cacheWrite1h.costPerMillion}/M = $${new Decimal(breakdown.cacheWrite1h.cost).toFixed(6)}`);
+        }
+      } else {
+        await log(`        Cache write: ${formatNumber(breakdown.cacheWrite.tokens)} tokens × $${breakdown.cacheWrite.costPerMillion}/M = $${new Decimal(breakdown.cacheWrite.cost).toFixed(6)}`);
       }
     }
+    if (breakdown.cacheRead.tokens > 0) {
+      await log(`        Cache read: ${formatNumber(breakdown.cacheRead.tokens)} tokens × $${breakdown.cacheRead.costPerMillion}/M = $${new Decimal(breakdown.cacheRead.cost).toFixed(6)}`);
+    }
+    if (breakdown.output.tokens > 0) {
+      await log(`        Output: ${formatNumber(breakdown.output.tokens)} tokens × $${breakdown.output.costPerMillion}/M = $${new Decimal(breakdown.output.cost).toFixed(6)}`);
+    }
     // Issue #1710: itemise server-tool charges so the residual that puzzled
     // readers in PR #1707 ($0.04 web_search) is visible in the breakdown.
     if (breakdown.webSearch && breakdown.webSearch.requests > 0) {

package/src/claude.cost.lib.mjs

@@ -8,12 +8,22 @@
 import Decimal from 'decimal.js-light';
 import { SERVER_TOOL_PRICING_USD } from './anthropic-server-tool-pricing.lib.mjs';
 
+const getCacheWrite5mPrice = cost => cost.cache_write_5m ?? cost.cache_write ?? 0;
+
+const getCacheWrite1hPrice = (cost, cacheWrite5mPrice) => {
+  if (cost.cache_write_1h !== undefined && cost.cache_write_1h !== null) return cost.cache_write_1h;
+  if (cost.input) return new Decimal(cost.input).mul(2).toNumber();
+  if (cacheWrite5mPrice) return new Decimal(cacheWrite5mPrice).mul(1.6).toNumber();
+  return 0;
+};
+
 /**
  * Calculate USD cost for a model's usage with optional detailed breakdown.
  *
  * Cost components (Issue #1600 uses Decimal for precision):
  *   - input        × cost.input        / 1M
- *   - cacheWrite   × cost.cache_write  / 1M
+ *   - cacheWrite5m × cost.cache_write  / 1M
+ *   - cacheWrite1h × (cost.cache_write_1h || cost.input × 2) / 1M
  *   - cacheRead    × cost.cache_read   / 1M
  *   - output       × cost.output       / 1M
  *   - webSearch    × $0.01 / request   (Issue #1710 — see SERVER_TOOL_PRICING_USD)
@@ -32,6 +42,8 @@ export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) =
   const breakdown = {
     input: { tokens: 0, costPerMillion: 0, cost: 0 },
     cacheWrite: { tokens: 0, costPerMillion: 0, cost: 0 },
+    cacheWrite5m: { tokens: 0, costPerMillion: 0, cost: 0 },
+    cacheWrite1h: { tokens: 0, costPerMillion: 0, cost: 0 },
     cacheRead: { tokens: 0, costPerMillion: 0, cost: 0 },
     output: { tokens: 0, costPerMillion: 0, cost: 0 },
     // Issue #1710: server-side tool usage (web_search) is billed per-request,
@@ -47,11 +59,35 @@ export const calculateModelCost = (usage, modelInfo, includeBreakdown = false) =
       cost: new Decimal(usage.inputTokens).div(million).mul(new Decimal(cost.input)).toNumber(),
     };
   }
-  if (usage.cacheCreationTokens && cost.cache_write) {
+  const explicitCacheWrite5mTokens = usage.cacheCreation5mTokens || 0;
+  const explicitCacheWrite1hTokens = usage.cacheCreation1hTokens || 0;
+  const explicitCacheWriteTokens = explicitCacheWrite5mTokens + explicitCacheWrite1hTokens;
+  const cacheWriteTokens = Math.max(usage.cacheCreationTokens || 0, explicitCacheWriteTokens);
+  const hasCacheWriteTtlSplit = explicitCacheWriteTokens > 0;
+  const unsplitCacheWriteTokens = hasCacheWriteTtlSplit ? Math.max(0, cacheWriteTokens - explicitCacheWriteTokens) : cacheWriteTokens;
+  const cacheWrite5mTokens = hasCacheWriteTtlSplit ? explicitCacheWrite5mTokens + unsplitCacheWriteTokens : cacheWriteTokens;
+  const cacheWrite1hTokens = hasCacheWriteTtlSplit ? explicitCacheWrite1hTokens : 0;
+  const cacheWrite5mPrice = getCacheWrite5mPrice(cost);
+  const cacheWrite1hPrice = getCacheWrite1hPrice(cost, cacheWrite5mPrice);
+  if (cacheWriteTokens && (cacheWrite5mPrice || cacheWrite1hPrice)) {
+    const cacheWrite5mCost = new Decimal(cacheWrite5mTokens).div(million).mul(new Decimal(cacheWrite5mPrice)).toNumber();
+    const cacheWrite1hCost = new Decimal(cacheWrite1hTokens).div(million).mul(new Decimal(cacheWrite1hPrice)).toNumber();
+    const cacheWriteCost = new Decimal(cacheWrite5mCost).plus(new Decimal(cacheWrite1hCost)).toNumber();
     breakdown.cacheWrite = {
-      tokens: usage.cacheCreationTokens,
-      costPerMillion: cost.cache_write,
-      cost: new Decimal(usage.cacheCreationTokens).div(million).mul(new Decimal(cost.cache_write)).toNumber(),
+      tokens: cacheWriteTokens,
+      costPerMillion: hasCacheWriteTtlSplit ? new Decimal(cacheWriteCost).div(new Decimal(cacheWriteTokens)).mul(million).toNumber() : cacheWrite5mPrice,
+      cost: cacheWriteCost,
+      hasExplicitTtlSplit: hasCacheWriteTtlSplit,
+    };
+    breakdown.cacheWrite5m = {
+      tokens: cacheWrite5mTokens,
+      costPerMillion: cacheWrite5mPrice,
+      cost: cacheWrite5mCost,
+    };
+    breakdown.cacheWrite1h = {
+      tokens: cacheWrite1hTokens,
+      costPerMillion: cacheWrite1hPrice,
+      cost: cacheWrite1hCost,
     };
   }
   if (usage.cacheReadTokens && cost.cache_read) {