tokentracker-cli 1.4.6 → 1.4.9

package/src/lib/local-usage-transfer.js

@@ -0,0 +1,271 @@
+"use strict";
+
+const fs = require("node:fs/promises");
+const { createReadStream } = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const { openLock, writeFileAtomic } = require("./fs");
+const { isAccountLevelSource } = require("./source-metadata");
+
+const SCHEMA = "tokentracker.local-usage.v1";
+const MAX_BYTES = 5 * 1024 * 1024;
+const MAX_STATE_BYTES = 64 * 1024 * 1024;
+const MAX_DEVICES = 32;
+const TOKEN_FIELDS = ["input_tokens", "output_tokens", "cached_input_tokens", "cache_creation_input_tokens",
+  "reasoning_output_tokens", "total_tokens", "billable_total_tokens", "conversation_count",
+  ...["long_context_", "priority_", "priority_long_context_"].flatMap((prefix) =>
+    ["input_tokens", "output_tokens", "cached_input_tokens", "cache_creation_input_tokens", "reasoning_output_tokens"].map((field) => prefix + field))];
+const ROW_FIELDS = new Set(["source", "model", "hour_start", "total_cost_usd", ...TOKEN_FIELDS]);
+const validId = (id) => typeof id === "string" && /^[A-Za-z0-9_-]{8,128}$/.test(id);
+const validTime = (value) => typeof value === "string" && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+const digest = (value) => crypto.createHash("sha256").update(JSON.stringify(value)).digest("hex");
+function fail(code, status = 400) { throw Object.assign(new Error(code), { code, status }); }
+function count(rows, field = "total_tokens") {
+  const result = rows.reduce((sum, row) => sum + (row[field] ?? row.total_tokens), 0);
+  if (!Number.isSafeInteger(result)) fail("invalid_snapshot");
+  return result;
+}
+function displayCount(rows) {
+  const total = count(rows);
+  return count(rows, "billable_total_tokens") || total;
+}
+
+function cleanRow(row, strict = false) {
+  if (!row || typeof row !== "object" || Array.isArray(row) ||
+      !Number.isSafeInteger(row.total_tokens) || row.total_tokens < 0 ||
+      typeof row.source !== "string" || !/^[a-z0-9_-]{1,80}$/.test(row.source) ||
+      typeof row.model !== "string" || !row.model.trim() || row.model.length > 200 || /[\x00-\x1f]/.test(row.model) ||
+      !validTime(row.hour_start) || Date.parse(row.hour_start) % 1_800_000 !== 0 ||
+      (strict && Object.keys(row).some((key) => !ROW_FIELDS.has(key)))) fail("invalid_snapshot");
+  const result = { source: row.source, model: row.model, hour_start: row.hour_start };
+  for (const field of TOKEN_FIELDS) {
+    const value = row[field] ?? (field === "billable_total_tokens" ? row.total_tokens : 0);
+    if (!Number.isSafeInteger(value) || value < 0) fail("invalid_snapshot");
+    if (value || Object.hasOwn(row, field) || field === "total_tokens" || field === "billable_total_tokens") result[field] = value;
+  }
+  if (Object.hasOwn(row, "total_cost_usd")) {
+    if (!Number.isFinite(row.total_cost_usd) || row.total_cost_usd < 0) fail("invalid_snapshot");
+    result.total_cost_usd = row.total_cost_usd;
+  }
+  return result;
+}
+
+function validateSnapshot(value) {
+  if (!value || value.schema !== SCHEMA || value.scope !== "device-history" ||
+      Object.keys(value).some((key) => !["schema", "scope", "machine", "sequence", "exported_at", "rows"].includes(key)) ||
+      !validId(value.machine?.id) || typeof value.machine.name !== "string" || value.machine.name.length > 128 ||
+      /[\x00-\x1f]/.test(value.machine.name) || typeof value.machine.platform !== "string" || value.machine.platform.length > 30 ||
+      Object.keys(value.machine).some((key) => !["id", "name", "platform"].includes(key)) ||
+      !Number.isSafeInteger(value.sequence) || value.sequence < 1 || !validTime(value.exported_at) ||
+      !Array.isArray(value.rows) || value.rows.length > 100_000 || Buffer.byteLength(JSON.stringify(value)) > MAX_BYTES) fail("invalid_snapshot");
+  const rows = value.rows.map((row) => cleanRow(row, true));
+  const keys = new Set();
+  for (const row of rows) {
+    const key = JSON.stringify([row.source, row.model, row.hour_start]);
+    if (isAccountLevelSource(row.source) || keys.has(key)) fail("invalid_snapshot");
+    keys.add(key);
+  }
+  count(rows);
+  // cleanRow may insert billable_total_tokens and drop omitted zeros, so the
+  // serialized size after normalization can exceed the pre-clean check above.
+  // Reject before commit: an accepted oversize snapshot would make later
+  // validateSnapshot reads fail and hide the import from Settings removal.
+  const normalized = { ...value, machine: { ...value.machine }, rows };
+  if (Buffer.byteLength(JSON.stringify(normalized)) > MAX_BYTES) fail("invalid_snapshot");
+  return normalized;
+}
+
+// Imported snapshots never enter the append-only queue or its cloud upload offset.
+// Keep rows separate until aggregation so pricing annotations and device identity
+// survive (e.g. reported costs and long-context/priority subsets).
+function createLocalUsageTransfer({ queuePath, normalizeRow, identity }) {
+  const directory = path.dirname(queuePath);
+  const statePath = path.join(directory, "local-usage.json");
+  let cachedRaw;
+  let cachedState;
+  let cachedView;
+  const importedCache = new WeakMap();
+  async function state() {
+    try {
+      const chunks = [];
+      let size = 0;
+      // Open once and bound the actual read, including a possible growth or
+      // replacement since another process last observed the ledger's size.
+      for await (const chunk of createReadStream(statePath, { end: MAX_STATE_BYTES })) {
+        size += chunk.length;
+        if (size > MAX_STATE_BYTES) fail("invalid_state", 503);
+        chunks.push(chunk);
+      }
+      const raw = Buffer.concat(chunks, size).toString("utf8");
+      if (raw === cachedRaw) return cachedState;
+      const value = JSON.parse(raw);
+      if (value.version !== 1 || !Number.isSafeInteger(value.revision) || value.revision < 0 ||
+          !Number.isSafeInteger(value.sequence) || value.sequence < 0 || !value.imports ||
+          typeof value.imports !== "object" || Array.isArray(value.imports) || Object.keys(value.imports).length > MAX_DEVICES) fail("invalid_state", 503);
+      cachedRaw = raw;
+      cachedState = value;
+      return value;
+    } catch (error) {
+      if (error.code === "ENOENT") return { version: 1, revision: 0, sequence: 0, imports: {} };
+      fail("invalid_state", 503);
+    }
+  }
+  async function ownRows() {
+    let raw;
+    try { raw = await fs.readFile(queuePath, "utf8"); }
+    catch (error) { if (error.code === "ENOENT") return []; throw error; }
+    const rows = new Map();
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      let row;
+      try { row = JSON.parse(line); } catch { fail("invalid_queue", 409); }
+      if (!row || typeof row !== "object") fail("invalid_queue", 409);
+      if (Object.hasOwn(row, "_ttsync")) fail("legacy_imports", 409);
+      if (row.kind) continue;
+      const normalized = normalizeRow(row);
+      if (!Number.isFinite(Date.parse(normalized.hour_start))) fail("invalid_queue", 409);
+      // A field allowlist is essential: never export arbitrary parser metadata.
+      const clean = cleanRow({ ...normalized, hour_start: new Date(normalized.hour_start).toISOString() });
+      rows.set(JSON.stringify([clean.source, clean.model, clean.hour_start]), clean);
+    }
+    return [...rows.values()];
+  }
+  async function locked(action) {
+    await fs.mkdir(directory, { recursive: true });
+    const locks = [];
+    try {
+      for (const name of ["local-usage.lock", "sync.lock"]) {
+        const lock = await openLock(path.join(directory, name), { quietIfLocked: true });
+        if (!lock) fail("transfer_busy", 409);
+        locks.push(lock);
+      }
+      return await action();
+    } finally { for (const lock of locks.reverse()) await lock.release(); }
+  }
+  async function write(value) {
+    value.revision++;
+    if (!Number.isSafeInteger(value.revision)) fail("invalid_state", 503);
+    const contents = JSON.stringify(value) + "\n";
+    if (Buffer.byteLength(contents) > MAX_STATE_BYTES) fail("too_many_devices");
+    await writeFileAtomic(statePath, contents, { mode: 0o600 });
+    cachedRaw = undefined;
+    cachedState = undefined;
+  }
+  function self() {
+    const machine = identity();
+    if (!validId(machine?.id)) fail("identity_unavailable", 503);
+    return { id: machine.id, name: String(machine.name || machine.id).slice(0, 128), platform: String(machine.platform || "").slice(0, 30) };
+  }
+  function imported(value) {
+    if (importedCache.has(value)) return importedCache.get(value);
+    const entries = Object.entries(value.imports).map(([id, entry]) => {
+      const snapshot = validateSnapshot(entry.snapshot);
+      if (snapshot.machine.id !== id || !validTime(entry.imported_at)) fail("invalid_state", 503);
+      return { ...entry, snapshot };
+    });
+    importedCache.set(value, entries);
+    return entries;
+  }
+  function inspect(snapshot, value, rows) {
+    if (snapshot.machine.id === self().id) fail("self_import");
+    const previous = Object.hasOwn(value.imports, snapshot.machine.id) ? value.imports[snapshot.machine.id].snapshot : null;
+    const same = previous && snapshot.sequence === previous.sequence;
+    if (same && digest(snapshot) !== digest(previous)) fail("snapshot_conflict", 409);
+    const action = !previous ? "added" : same ? "unchanged" : snapshot.sequence < previous.sequence ? "outdated" : "updated";
+    const entries = imported(value);
+    const own = rows.filter((row) => !isAccountLevelSource(row.source));
+    const before = displayCount([...own, ...entries.flatMap((entry) => entry.snapshot.rows)]);
+    const after = ["added", "updated"].includes(action) ? displayCount([...own, ...snapshot.rows,
+      ...entries.filter((entry) => entry.snapshot.machine.id !== snapshot.machine.id).flatMap((entry) => entry.snapshot.rows)]) : before;
+    return { action, before, after, machine: snapshot.machine, exported_at: snapshot.exported_at,
+      token: digest([snapshot, value.revision, rows]) };
+  }
+  return {
+    async exportSnapshot() {
+      return locked(async () => {
+        const value = structuredClone(await state());
+        const rows = (await ownRows()).filter((row) => !isAccountLevelSource(row.source));
+        const snapshot = validateSnapshot({ schema: SCHEMA, scope: "device-history", machine: self(),
+          sequence: value.sequence + 1, exported_at: new Date().toISOString(), rows });
+        value.sequence++;
+        await write(value);
+        return snapshot;
+      });
+    },
+    async preview(input) {
+      const snapshot = validateSnapshot(input);
+      return locked(async () => inspect(snapshot, await state(), await ownRows()));
+    },
+    async importSnapshot(input, token) {
+      const snapshot = validateSnapshot(input);
+      return locked(async () => {
+        const value = structuredClone(await state());
+        const preview = inspect(snapshot, value, await ownRows());
+        if (preview.token !== token) fail("preview_changed", 409);
+        if (["added", "updated"].includes(preview.action)) {
+          if (preview.action === "added" && Object.keys(value.imports).length >= MAX_DEVICES) fail("too_many_devices");
+          value.imports = { ...value.imports, [snapshot.machine.id]: { snapshot, imported_at: new Date().toISOString() } };
+          await write(value);
+        }
+        return preview;
+      });
+    },
+    async remove(id) {
+      if (!validId(id)) fail("unknown_device", 404);
+      return locked(async () => {
+        const value = structuredClone(await state());
+        if (!Object.hasOwn(value.imports, id)) fail("unknown_device", 404);
+        delete value.imports[id];
+        await write(value);
+      });
+    },
+    async hasImports() { return imported(await state()).length > 0; },
+    async view(rows, device = "") {
+      const value = await state();
+      if (!device) {
+        const entries = imported(value);
+        if (!entries.length) return rows;
+        if (cachedView?.own === rows && cachedView.state === value) return cachedView.rows;
+        const combined = [...rows, ...entries.flatMap((entry) => entry.snapshot.rows)];
+        cachedView = { own: rows, state: value, rows: combined };
+        return combined;
+      }
+      if (device === `local:${self().id}`) return rows.filter((row) => !isAccountLevelSource(row.source));
+      const entry = imported(value).find((item) => device === `local:${item.snapshot.machine.id}`);
+      if (!entry) fail("unknown_device", 404);
+      return entry.snapshot.rows;
+    },
+    async devices(rows, inRange) {
+      const value = await state();
+      const machine = self();
+      const entries = imported(value);
+      const rangeTotals = (rows) => {
+        const selected = rows.filter(inRange);
+        return { total_tokens: count(selected), billable_total_tokens: count(selected, "billable_total_tokens") };
+      };
+      const devices = [{ id: `local:${machine.id}`, machine_id: machine.id, device_name: machine.name,
+        platform: machine.platform, isCurrent: true,
+        ...rangeTotals(rows.filter((row) => !isAccountLevelSource(row.source))) },
+      ...entries.map(({ snapshot, imported_at }) => ({ id: `local:${snapshot.machine.id}`, machine_id: snapshot.machine.id,
+        device_name: snapshot.machine.name, platform: snapshot.machine.platform,
+        ...rangeTotals(snapshot.rows), imported_at, exported_at: snapshot.exported_at }))];
+      const accounts = new Map();
+      for (const row of rows.filter((row) => isAccountLevelSource(row.source) && inRange(row))) {
+        const totals = accounts.get(row.source) || { total_tokens: 0, billable_total_tokens: 0 };
+        totals.total_tokens += row.total_tokens;
+        totals.billable_total_tokens += row.billable_total_tokens ?? row.total_tokens;
+        accounts.set(row.source, totals);
+      }
+      const names = devices.map((device) => device.device_name);
+      for (const device of devices) {
+        if (names.filter((name) => name === device.device_name).length > 1) {
+          device.device_name += ` · ${device.machine_id.slice(-8)}`;
+        }
+      }
+      return { revision: value.revision, current_device_id: `local:${machine.id}`, devices,
+        account_sources: [...accounts].map(([source, totals]) => ({ source, ...totals })) };
+    },
+  };
+}
+
+module.exports = { createLocalUsageTransfer, MAX_BYTES };

package/src/lib/opencode-go-limits.js

@@ -2,9 +2,15 @@ const crypto = require("node:crypto");
 const fssync = require("node:fs");
 const path = require("node:path");
 const { readSqliteJsonRowsAsync } = require("./sqlite-reader");
+const { readStoredApiKey } = require("./provider-api-key-store");
 
 // OpenCode Go usage limits.
 //
+// The API key comes from OPENCODE_GO_API_KEY when set, otherwise from the key
+// saved in the Limits panel (provider-api-key-store.js). The stored key exists
+// so users never need a machine-wide `launchctl setenv`, which reaches every
+// launchd app on macOS and not just TokenTracker (#837).
+//
 // Three data sources are available, in priority order:
 //
 //   1. The official OpenCode Go usage API
@@ -732,13 +738,17 @@ async function scrapeOpencodeGoWeb({ cfg, fetchImpl, nowMs, timeoutMs }) {
 
 async function fetchOpencodeGoLimits({
   home,
+  trackerDir,
   env = process.env,
   fetchImpl = fetch,
   nowMs = Date.now(),
   timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
   sqliteOptions = {},
 } = {}) {
-  const apiKey = readApiKey(env);
+  const envApiKey = readApiKey(env);
+  const apiKey =
+    envApiKey || readStoredApiKey({ provider: "opencode-go", trackerDir, home });
+  const credentialSource = envApiKey ? "env" : apiKey ? "stored" : null;
   const cfg = readConfig(env);
   const allowLocalEstimate = localEstimateEnabled(env);
 
@@ -748,13 +758,14 @@ async function fetchOpencodeGoLimits({
   // existing cookie remains a compatibility fallback.
   if (apiKey) {
     const api = await fetchOpencodeGoApiLimits({ apiKey, fetchImpl, nowMs, timeoutMs });
-    if (!api?.error && (api.primary_window || api.secondary_window || api.tertiary_window)) {
-      return { ...api, source: "api" };
+    const sourcedApi = credentialSource ? { ...api, credential_source: credentialSource } : api;
+    if (!sourcedApi?.error && (sourcedApi.primary_window || sourcedApi.secondary_window || sourcedApi.tertiary_window)) {
+      return { ...sourcedApi, source: "api" };
     }
-    if (api?.auth_error) {
-      return { ...api, source: "api" };
+    if (sourcedApi?.auth_error) {
+      return { ...sourcedApi, source: "api" };
     }
-    if (!cfg) return api || { configured: true, error: "OpenCode Go unavailable" };
+    if (!cfg) return sourcedApi || { configured: true, error: "OpenCode Go unavailable" };
   }
 
   // Keep the cookie-backed dashboard path for existing configurations and as a

package/src/lib/pricing/curated-overrides.json

@@ -89,12 +89,27 @@
       "cache_write": 1.25,
       "note": "Canonical undated alias emitted by Cursor. Pin to the same rates as claude-haiku-4-5-20251001 so local cost does not depend on which dated LiteLLM aliases are present in the current cache."
     },
+    "claude-haiku-5-5": {
+      "input": 0.1,
+      "output": 0.5,
+      "cache_read": 0.01,
+      "cache_write": 0.125,
+      "note": "Official Anthropic Haiku 5.5 short-context (prompts <=100K) USD/MTok verified 2026-10-22: https://platform.claude.com/docs/en/about-claude/pricing. Prompts over 100K use 5x rates; computeRowCost does not yet split that long-prompt tier. Cache write is the 5-minute rate."
+    },
+    "claude-haiku-5.5": {
+      "input": 0.1,
+      "output": 0.5,
+      "cache_read": 0.01,
+      "cache_write": 0.125,
+      "note": "Dotted alias for claude-haiku-5-5. Same short-context rates."
+    },
     "gpt-6-astra": {
       "input": 10,
       "output": 50,
       "cache_read": 1,
       "cache_write": 12.5,
       "priority_multiplier": 2,
+      "ultrafast_multiplier": 6,
       "note": "Official Standard USD/MTok rates verified 2026-09-07: https://developers.openai.com/api/docs/models/gpt-6-astra. Requests above 272K input tokens use 2x input/cache and 1.5x output rates; computeRowCost applies this only to observed long-context request subsets. priority_multiplier is the Fast tier, whose published table (20/2/25/100 short, 40/4/50/150 long, verified 2026-09-12) is exactly 2x the Standard rate of the same context tier — it multiplies, it does not replace, the long-context premium. The 2.5x figure in the Codex speed docs is a subscription-credit rate and must not be used here. computeRowCost applies it only to observed priority request subsets; usage whose service tier the logs never recorded stays Standard. Cloud aggregates use Standard short-context estimates because they do not retain per-request context or service tier. Reasoning-effort suffixes use the same base rates."
     },
     "gpt-6.1-sol": {
@@ -103,6 +118,7 @@
       "cache_read": 0.1,
       "cache_write": 2.5,
       "priority_multiplier": 2,
+      "ultrafast_multiplier": 6,
       "note": "Official Standard USD/MTok rates verified 2026-10-02 (issue #737): https://developers.openai.com/api/docs/models/gpt-6.1-sol. Requests above 272K input use 2x input/cache and 1.5x output rates; Fast mode is 2x the applicable rates. Premiums apply only to observed request subsets. Cloud aggregates remain Standard short-context estimates."
     },
     "gpt-6-sol": {
@@ -682,6 +698,14 @@
       "match": "composer",
       "ref": "composer-1"
     },
+    {
+      "match": "haiku-5-5",
+      "ref": "claude-haiku-5-5"
+    },
+    {
+      "match": "haiku-5.5",
+      "ref": "claude-haiku-5.5"
+    },
     {
       "match": "claude-opus-5-fast",
       "ref": "claude-opus-5-fast"

package/src/lib/pricing/index.js

@@ -273,7 +273,9 @@ function computeRowCost(row) {
   // and inventing one is worse than reporting Standard.
   const priorityMultiplier = Number(pricing.priority_multiplier);
   const hasPriorityRates = Number.isFinite(priorityMultiplier) && priorityMultiplier > 1;
-  if (!usesOpenAILongContextTier && !hasPriorityRates) return baseCost;
+  const ultrafastMultiplierEarly = Number(pricing.ultrafast_multiplier);
+  const hasUltrafastRatesEarly = Number.isFinite(ultrafastMultiplierEarly) && ultrafastMultiplierEarly > 1;
+  if (!usesOpenAILongContextTier && !hasPriorityRates && !hasUltrafastRatesEarly) return baseCost;
 
   const bounded = (value, total) => Math.min(
     Math.max(0, Number(value) || 0),
@@ -306,7 +308,49 @@ function computeRowCost(row) {
     0.5 * longReasoning * (pricing.output || 0)
   ) / 1_000_000 : 0;
 
-  if (!hasPriorityRates) return baseCost + longContextPremium;
+  const ultrafastMultiplier = ultrafastMultiplierEarly;
+  const hasUltrafastRates = hasUltrafastRatesEarly;
+  if (!hasPriorityRates && !hasUltrafastRates) return baseCost + longContextPremium;
+
+  // Shared helper: premium for one observed speed-tier subset. Fast and Ultrafast
+  // are mutually exclusive per request; both can appear in one aggregated row.
+  function tierPremium(multiplier, prefix) {
+    if (!(Number.isFinite(multiplier) && multiplier > 1)) return 0;
+    const tierInput = bounded(row[`${prefix}input_tokens`], row.input_tokens);
+    const tierCached = bounded(row[`${prefix}cached_input_tokens`], row.cached_input_tokens);
+    const tierCacheWrite = bounded(
+      row[`${prefix}cache_creation_input_tokens`],
+      row.cache_creation_input_tokens,
+    );
+    const tierOutput = bounded(row[`${prefix}output_tokens`], row.output_tokens);
+    const tierReasoning = reasoningIncludedInOutput
+      ? 0
+      : bounded(row[`${prefix}reasoning_output_tokens`], row.reasoning_output_tokens);
+    const tierBase = (
+      tierInput * (pricing.input || 0) +
+      tierCached * (pricing.cache_read || 0) +
+      tierCacheWrite * (pricing.cache_write || 0) +
+      tierOutput * (pricing.output || 0) +
+      tierReasoning * (pricing.output || 0)
+    ) / 1_000_000;
+    const tierLong = usesOpenAILongContextTier ? (
+      bounded(row[`${prefix}long_context_input_tokens`], Math.min(tierInput, longInput)) *
+        (pricing.input || 0) +
+      bounded(row[`${prefix}long_context_cached_input_tokens`], Math.min(tierCached, longCached)) *
+        (pricing.cache_read || 0) +
+      bounded(
+        row[`${prefix}long_context_cache_creation_input_tokens`],
+        Math.min(tierCacheWrite, longCacheWrite),
+      ) * (pricing.cache_write || 0) +
+      0.5 * bounded(row[`${prefix}long_context_output_tokens`], Math.min(tierOutput, longOutput)) *
+        (pricing.output || 0) +
+      0.5 * bounded(
+        row[`${prefix}long_context_reasoning_output_tokens`],
+        Math.min(tierReasoning, longReasoning),
+      ) * (pricing.output || 0)
+    ) / 1_000_000 : 0;
+    return (multiplier - 1) * (tierBase + tierLong);
+  }
 
   // Astra Fast is a flat multiple of whichever context tier the request was on
   // (short 10/1/12.5/50 -> 20/2/25/100; long 20/2/25/75 -> 40/4/50/150), so the
@@ -316,43 +360,10 @@ function computeRowCost(row) {
   // priority_long_context_* alongside priority_*; without it (queue rows, which
   // carry no context-length subset at all) the overlap is 0 and the premium
   // falls back to the short-context multiple, matching the row's own base.
-  const priorityInput = bounded(row.priority_input_tokens, row.input_tokens);
-  const priorityCached = bounded(row.priority_cached_input_tokens, row.cached_input_tokens);
-  const priorityCacheWrite = bounded(
-    row.priority_cache_creation_input_tokens,
-    row.cache_creation_input_tokens,
-  );
-  const priorityOutput = bounded(row.priority_output_tokens, row.output_tokens);
-  const priorityReasoning = reasoningIncludedInOutput
-    ? 0
-    : bounded(row.priority_reasoning_output_tokens, row.reasoning_output_tokens);
-  const priorityBase = (
-    priorityInput * (pricing.input || 0) +
-    priorityCached * (pricing.cache_read || 0) +
-    priorityCacheWrite * (pricing.cache_write || 0) +
-    priorityOutput * (pricing.output || 0) +
-    priorityReasoning * (pricing.output || 0)
-  ) / 1_000_000;
-
-  const priorityLong = usesOpenAILongContextTier ? (
-    bounded(row.priority_long_context_input_tokens, Math.min(priorityInput, longInput)) *
-      (pricing.input || 0) +
-    bounded(row.priority_long_context_cached_input_tokens, Math.min(priorityCached, longCached)) *
-      (pricing.cache_read || 0) +
-    bounded(
-      row.priority_long_context_cache_creation_input_tokens,
-      Math.min(priorityCacheWrite, longCacheWrite),
-    ) * (pricing.cache_write || 0) +
-    0.5 * bounded(row.priority_long_context_output_tokens, Math.min(priorityOutput, longOutput)) *
-      (pricing.output || 0) +
-    0.5 * bounded(
-      row.priority_long_context_reasoning_output_tokens,
-      Math.min(priorityReasoning, longReasoning),
-    ) * (pricing.output || 0)
-  ) / 1_000_000 : 0;
-
-  const priorityPremium = (priorityMultiplier - 1) * (priorityBase + priorityLong);
-  return baseCost + longContextPremium + priorityPremium;
+  // Ultrafast mirrors the same shape with ultrafast_* / ultrafast_multiplier (6x).
+  const priorityPremium = tierPremium(priorityMultiplier, "priority_");
+  const ultrafastPremium = tierPremium(ultrafastMultiplier, "ultrafast_");
+  return baseCost + longContextPremium + priorityPremium + ultrafastPremium;
 }
 
 // Backwards-compatible MODEL_PRICING export. Test at

package/src/lib/pricing/matcher.js

@@ -280,6 +280,15 @@ function lookupPricing(model, { curated, litellm, source } = {}) {
       value: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
     };
   }
+  // OpenCode Zen free models carry a `-free` suffix on the paid model id
+  // (`deepseek-v4.1-flash-free`); the base-name fuzzy match must not bill them.
+  if (sourceKey === "opencode" && lower.endsWith("-free")) {
+    return {
+      hit: true,
+      source: "curated:opencode-free-suffix",
+      value: { input: 0, output: 0, cache_read: 0, cache_write: 0 },
+    };
+  }
   // AStudio does not disclose its routed model. Stop before generic aliases
   // and fuzzy matching can turn an unresolved router into a priced model.
   if (sourceKey === "acode" && (lower === "auto" || lower.endsWith("-auto"))) {