chainlesschain 0.166.97 → 0.166.99

package/src/lib/eval/verify01-workspace.js

@@ -0,0 +1,302 @@
+/** Shared file boundaries and snapshots; no process broker or npm dependencies. */
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { evalDigest } from "./evidence.js";
+const MAX_BYTES = 16 * 1024 * 1024;
+export const MAX_SNAPSHOT_BYTES = 512 * 1024 * 1024;
+const MAX_DIFF_BYTES = 32 * 1024 * 1024;
+const EMPTY_DELIVERABLE_DIGEST = evalDigest(Buffer.alloc(0));
+
+export function requireValue(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+export function relativeFile(value) {
+  requireValue(
+    typeof value === "string" &&
+      value.length > 0 &&
+      !value.includes("\0") &&
+      !/[\\:*?<>|"]/u.test(value) &&
+      !value.startsWith("/") &&
+      value.split("/").every((part) => part && !/[. ]$/u.test(part)),
+    "review paths must be exact relative files",
+  );
+  return value;
+}
+export function readBytes(file) {
+  const descriptor = fs.openSync(file, "r");
+  try {
+    const before = fs.fstatSync(descriptor, { bigint: true });
+    requireValue(
+      before.isFile() && before.size <= BigInt(MAX_BYTES),
+      "input must be a regular file within 16 MiB",
+    );
+    const bytes = Buffer.alloc(Number(before.size) + 1);
+    let count = 0;
+    while (count < bytes.length) {
+      const size = fs.readSync(
+        descriptor,
+        bytes,
+        count,
+        bytes.length - count,
+        null,
+      );
+      if (!size) break;
+      count += size;
+    }
+    const after = fs.fstatSync(descriptor, { bigint: true });
+    requireValue(
+      count === Number(before.size) &&
+        ["dev", "ino", "size", "mtimeNs", "ctimeNs"].every(
+          (key) => before[key] === after[key],
+        ),
+      "input changed during read",
+    );
+    return bytes.subarray(0, count);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+export function canonicalDirectory(directory) {
+  const absolute = path.resolve(directory);
+  const canonical = (fs.realpathSync.native || fs.realpathSync)(absolute);
+  const same =
+    process.platform === "win32"
+      ? canonical.toLowerCase() === absolute.toLowerCase()
+      : canonical === absolute;
+  const stat = fs.lstatSync(absolute);
+  requireValue(
+    same && stat.isDirectory() && !stat.isSymbolicLink(),
+    "task directory must be canonical and unaliased",
+  );
+  return canonical;
+}
+
+/** Trusted preparation only: a seed contains no answer and never overwrites
+ * a project file. Existing source paths are not passed to this helper. */
+export function seedVerify01Deliverables(directory, expectedFiles, budget) {
+  const root = canonicalDirectory(directory);
+  requireValue(
+    Array.isArray(expectedFiles) &&
+      expectedFiles.length > 0 &&
+      new Set(expectedFiles).size === expectedFiles.length,
+    "deliverable paths must be distinct",
+  );
+  expectedFiles.forEach(relativeFile);
+  const seeds = [];
+  for (const relative of expectedFiles) {
+    budget.remainingMs("deliverable-preparation");
+    let current = root;
+    for (const part of relative.split("/").slice(0, -1)) {
+      current = path.join(current, part);
+      within(root, current);
+      try {
+        fs.mkdirSync(current, { mode: 0o700 });
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+      canonicalDirectory(current);
+    }
+    const target = path.join(root, relative);
+    within(root, target);
+    const fd = fs.openSync(
+      target,
+      fs.constants.O_WRONLY |
+        fs.constants.O_CREAT |
+        fs.constants.O_EXCL |
+        (fs.constants.O_NOFOLLOW || 0),
+      0o600,
+    );
+    try {
+      const stat = fs.fstatSync(fd);
+      requireValue(
+        stat.isFile() && stat.nlink === 1 && stat.size === 0,
+        "seed must be an empty unaliased regular file",
+      );
+      regularPath(root, relative);
+      const named = fs.lstatSync(target);
+      requireValue(
+        named.dev === stat.dev && named.ino === stat.ino,
+        "seed path changed identity during preparation",
+      );
+      canonicalDirectory(path.dirname(target));
+      seeds.push(
+        Object.freeze({
+          path: relative,
+          before: null,
+          origin: "trusted-empty-deliverable-preparation",
+          digest: EMPTY_DELIVERABLE_DIGEST,
+          bytes: 0,
+          requestedMode: 0o600,
+          mode: stat.mode & 0o777,
+          preparedAt: new Date().toISOString(),
+        }),
+      );
+    } finally {
+      fs.closeSync(fd);
+    }
+  }
+  return Object.freeze(seeds);
+}
+
+export function within(root, file) {
+  const relative = path.relative(root, file);
+  requireValue(
+    relative &&
+      relative !== ".." &&
+      !relative.startsWith(`..${path.sep}`) &&
+      !path.isAbsolute(relative),
+    "path escapes its declared root",
+  );
+}
+
+export function regularPath(root, relative) {
+  relativeFile(relative);
+  const file = path.join(root, relative);
+  within(root, file);
+  let current = root;
+  for (const segment of relative.split("/")) {
+    current = path.join(current, segment);
+    requireValue(
+      !fs.lstatSync(current).isSymbolicLink(),
+      "review/project paths must not traverse links",
+    );
+  }
+  requireValue(
+    fs.lstatSync(file).isFile(),
+    "review/project artifact must be a regular file",
+  );
+  return file;
+}
+
+export function snapshotVerify01Workspace(directory, budget, stage) {
+  const files = new Map();
+  let total = 0;
+  let dependencyBytes = 0;
+  let dependencyFiles = 0;
+  const dependencyHash = createHash("sha256");
+  const buffer = Buffer.alloc(64 * 1024);
+  const visit = (current) => {
+    for (const entry of fs
+      .readdirSync(current, { withFileTypes: true })
+      .sort((a, b) => a.name.localeCompare(b.name, "en"))) {
+      budget.remainingMs(stage);
+      const full = path.join(current, entry.name);
+      const relative = path.relative(directory, full).split(path.sep).join("/");
+      if (entry.isDirectory()) visit(full);
+      else {
+        requireValue(
+          entry.isFile() || entry.isSymbolicLink(),
+          "task snapshot contains an unsupported filesystem object",
+        );
+        // Preserve link identities without following them into another root.
+        const dependency = relative.split("/").includes("node_modules");
+        if (dependency && entry.isSymbolicLink()) {
+          // A dependency linked outside the isolated workspace cannot be
+          // fingerprinted by this capture contract; never silently omit it.
+          within(directory, fs.realpathSync(full));
+        }
+        let bytes = entry.isSymbolicLink()
+          ? Buffer.from(fs.readlinkSync(full))
+          : dependency
+            ? null
+            : readBytes(full);
+        let digest, size;
+        if (dependency && bytes === null) {
+          const hash = createHash("sha256");
+          const fd = fs.openSync(full, "r");
+          size = 0;
+          try {
+            let count;
+            while (
+              (count = fs.readSync(fd, buffer, 0, buffer.length, null)) > 0
+            ) {
+              budget.remainingMs(stage);
+              size += count;
+              requireValue(
+                dependencyBytes + size <= 16 * 1024 ** 3,
+                "dependency fingerprint exceeds 16 GiB",
+              );
+              hash.update(buffer.subarray(0, count));
+            }
+          } finally {
+            fs.closeSync(fd);
+          }
+          digest = `sha256:${hash.digest("hex")}`;
+        } else {
+          size = bytes.length;
+          digest = evalDigest(bytes);
+        }
+        if (dependency) {
+          dependencyBytes += size;
+          dependencyFiles++;
+          bytes = null;
+        } else total += size;
+        requireValue(
+          total <= MAX_SNAPSHOT_BYTES &&
+            files.size - dependencyFiles < 100000 &&
+            dependencyFiles <= 1000000,
+          "task snapshot exceeds its capture bound",
+        );
+        const value = {
+          type: entry.isSymbolicLink() ? "link" : "file",
+          mode: fs.lstatSync(full).mode & 0o777,
+          bytes,
+          size,
+          digest,
+          dependency,
+        };
+        files.set(relative, value);
+        if (dependency)
+          dependencyHash.update(
+            JSON.stringify([relative, value.type, value.mode, size, digest]) +
+              "\n",
+          );
+      }
+    }
+  };
+  visit(directory);
+  files.dependencyBoundary = {
+    contract:
+      "all node_modules files and link identities streamed with SHA-256; links never followed; dependency bodies omitted; every change rejected",
+    files: dependencyFiles,
+    bytes: dependencyBytes,
+    digest: `sha256:${dependencyHash.digest("hex")}`,
+  };
+  return files;
+}
+
+export function diffVerify01Workspace(before, after) {
+  const result = [];
+  let total = 0;
+  for (const file of [...new Set([...before.keys(), ...after.keys()])].sort()) {
+    const old = before.get(file),
+      next = after.get(file);
+    if (
+      old?.digest === next?.digest &&
+      old?.type === next?.type &&
+      old?.mode === next?.mode
+    )
+      continue;
+    total += (old?.bytes?.length || 0) + (next?.bytes?.length || 0);
+    requireValue(
+      total <= MAX_DIFF_BYTES,
+      "task diff exceeds 32 MiB; preserve workspace for independent inspection",
+    );
+    const describe = (value) =>
+      value
+        ? {
+            type: value.type,
+            mode: value.mode,
+            digest: value.digest,
+            bytes: value.size,
+            dependency: value.dependency,
+            bytesBase64: value.bytes?.toString("base64") ?? null,
+          }
+        : null;
+    result.push({ path: file, before: describe(old), after: describe(next) });
+  }
+  return result;
+}

package/src/lib/execution-location-failure-site.js

@@ -27,6 +27,24 @@ export function readExecutionLocationStorageFailure(stderr) {
   return match ? `${match[1]}${match[2] || ""}` : null;
 }
 
+export function readExecutionLocationStorageLaunchFailure(stderr) {
+  const match = String(stderr || "")
+    .slice(0, MAX_DIAGNOSTIC_CHARS)
+    .match(
+      /\[windows-acl-launch:(inspect|repair|preflight):(spawn|timeout):(startup|initialize|traversal|lookup|repair-lock|repair-inspect|repair-write|verify):(EACCES|EPERM|ENOENT|ETIMEDOUT|EINVAL|ENOSYS|ENOMEM|EMFILE|ENFILE|ENOBUFS|EBUSY|UNKNOWN):(unknown|-?(?:0|[1-9][0-9]{0,4})):(spawnSync|spawn|unknown)\]/u,
+    );
+  if (!match) return null;
+  const [, operation, failureStage, progressStage, code, rawErrno, syscall] =
+    match;
+  const errno = rawErrno === "unknown" ? null : Number(rawErrno);
+  if (
+    (errno !== null && Math.abs(errno) > 65535) ||
+    (failureStage === "timeout") !== (code === "ETIMEDOUT")
+  )
+    return null;
+  return { operation, failureStage, progressStage, code, errno, syscall };
+}
+
 export function executionLocationFailureSite(error) {
   const stack = String(error?.stack || "").slice(0, MAX_DIAGNOSTIC_CHARS);
   for (const frame of stack.split(/\r?\n/u).slice(1)) {

package/src/lib/execution-location-target.js

@@ -7,6 +7,7 @@ import { TextDecoder } from "node:util";
 import {
   readExecutionLocationFailureSite,
   readExecutionLocationStorageFailure,
+  readExecutionLocationStorageLaunchFailure,
 } from "./execution-location-failure-site.js";
 import {
   EXECUTION_LOCATION_TARGET_ATTESTATION_SCHEMA,
@@ -1039,6 +1040,10 @@ function targetProcessFailure(result) {
   error.failureCategory = failureCategory;
   if (failureSite) error.failureSite = failureSite;
   if (storageFailure) error.storageFailure = storageFailure;
+  const storageLaunchFailure = readExecutionLocationStorageLaunchFailure(
+    result.stderr,
+  );
+  if (storageLaunchFailure) error.storageLaunchFailure = storageLaunchFailure;
   return error;
 }
 
@@ -1108,6 +1113,11 @@ function runTargetCommand(profile, cliArgs, deps = {}, options = {}) {
       error.failureCategory = failureCategory;
       if (failureSite) error.failureSite = failureSite;
       if (storageFailure) error.storageFailure = storageFailure;
+      const storageLaunchFailure = readExecutionLocationStorageLaunchFailure(
+        result?.stderr,
+      );
+      if (storageLaunchFailure)
+        error.storageLaunchFailure = storageLaunchFailure;
       throw error;
     }
     return options.interactive ? null : result.stdout;

package/src/lib/llm-connection-probe.js

@@ -1,13 +1,141 @@
 import { formatProviderResponseError } from "./provider-http-error.js";
+import { estimateCost } from "./llm-pricing.js";
 
 // Reasoning models spend the same output allowance on thinking before the
 // final answer. A 16-token probe can therefore receive HTTP 200 with only
 // reasoning_content and finish_reason=length from an otherwise usable model.
 const PROBE_OUTPUT_TOKENS = 1024;
+export const LLM_PROBE_SCHEMA = "chainlesschain.llm-connection-probe/v1";
+
+const count = (value) => Number.isSafeInteger(value) && value >= 0;
+
+/** Preserve missing/malformed usage as unknown, including cached prompt tokens. */
+export function normalizeLlmProbeUsage(provider, data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+  let usage;
+  if (provider === "ollama") {
+    usage = {
+      input_tokens: data.prompt_eval_count,
+      output_tokens: data.eval_count,
+    };
+  } else if (provider === "anthropic") {
+    usage = data.usage;
+  } else if (provider === "gemini") {
+    const raw = data.usageMetadata;
+    if (
+      !raw ||
+      !count(raw.candidatesTokenCount) ||
+      !count(raw.thoughtsTokenCount === undefined ? 0 : raw.thoughtsTokenCount)
+    )
+      return null;
+    const cached =
+      raw.cachedContentTokenCount === undefined
+        ? 0
+        : raw.cachedContentTokenCount;
+    if (
+      !count(raw.promptTokenCount) ||
+      !count(cached) ||
+      cached > raw.promptTokenCount
+    )
+      return null;
+    usage = {
+      input_tokens: raw.promptTokenCount - cached,
+      output_tokens: raw.candidatesTokenCount + (raw.thoughtsTokenCount ?? 0),
+      cache_read_input_tokens: cached,
+    };
+  } else {
+    const raw = data.usage;
+    if (!raw || !count(raw.prompt_tokens) || !count(raw.completion_tokens))
+      return null;
+    const detailed = raw.prompt_tokens_details?.cached_tokens;
+    const legacy = raw.prompt_cache_hit_tokens;
+    const cached =
+      detailed === undefined ? (legacy === undefined ? 0 : legacy) : detailed;
+    if (
+      !count(cached) ||
+      cached > raw.prompt_tokens ||
+      (detailed !== undefined && legacy !== undefined && detailed !== legacy)
+    )
+      return null;
+    usage = {
+      input_tokens: raw.prompt_tokens - cached,
+      output_tokens: raw.completion_tokens,
+      cache_read_input_tokens: cached,
+    };
+  }
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
+  const normalized = {
+    input_tokens: usage.input_tokens,
+    output_tokens: usage.output_tokens,
+    cache_read_input_tokens:
+      usage.cache_read_input_tokens === undefined
+        ? 0
+        : usage.cache_read_input_tokens,
+    cache_creation_input_tokens:
+      usage.cache_creation_input_tokens === undefined
+        ? 0
+        : usage.cache_creation_input_tokens,
+  };
+  return Object.values(normalized).every(count) ? normalized : null;
+}
+
+export function priceLlmProbeUsage(target, usage) {
+  if (
+    !usage ||
+    ![
+      usage.input_tokens,
+      usage.output_tokens,
+      usage.cache_read_input_tokens,
+      usage.cache_creation_input_tokens,
+    ].every(count)
+  )
+    return null;
+  const estimate = estimateCost({
+    provider: target.provider,
+    model: target.model,
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    cacheReadTokens: usage.cache_read_input_tokens,
+    cacheCreationTokens: usage.cache_creation_input_tokens,
+  });
+  return estimate.matched && Number.isFinite(estimate.totalCost)
+    ? estimate.totalCost
+    : null;
+}
+
+export function llmProbeReceipt(
+  target,
+  { ok = false, reply = null, usage = null } = {},
+) {
+  const normalizedUsage =
+    usage === null
+      ? null
+      : {
+          input_tokens: usage.input_tokens,
+          output_tokens: usage.output_tokens,
+          cache_read_input_tokens: usage.cache_read_input_tokens,
+          cache_creation_input_tokens: usage.cache_creation_input_tokens,
+        };
+  return {
+    schema: LLM_PROBE_SCHEMA,
+    ok,
+    provider: target.provider,
+    model: target.model,
+    reply:
+      target.apiKey && typeof reply === "string"
+        ? reply.replaceAll(target.apiKey, "[REDACTED]")
+        : reply,
+    usage: normalizedUsage,
+    totalCostUsd: priceLlmProbeUsage(target, normalizedUsage),
+    currency: "USD",
+    costBasis: "token-estimate",
+    billingVerified: false,
+  };
+}
 
 export async function probeLlmConnection(
   target,
-  { fetchImpl = fetch, timeoutMs = 20_000 } = {},
+  { fetchImpl = fetch, timeoutMs = 20_000, includeUsage = false } = {},
 ) {
   const base = target.baseUrl.replace(/\/+$/, "");
   const headers = { "Content-Type": "application/json" };
@@ -50,6 +178,7 @@ export async function probeLlmConnection(
   }
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let usage = null;
   try {
     const response = await fetchImpl(url, {
       method: "POST",
@@ -60,9 +189,12 @@ export async function probeLlmConnection(
     });
     if (!response.ok)
       throw new Error(
-        await formatProviderResponseError(target.provider, response),
+        await formatProviderResponseError(target.provider, response, {
+          secrets: [target.apiKey],
+        }),
       );
     const data = await response.json();
+    usage = normalizeLlmProbeUsage(target.provider, data);
     const text =
       target.provider === "ollama"
         ? data.response
@@ -91,11 +223,20 @@ export async function probeLlmConnection(
         "The endpoint returned no model text; check the protocol and model",
       );
     }
-    return text.trim().slice(0, 100);
+    const reply = (
+      target.apiKey ? text.replaceAll(target.apiKey, "[REDACTED]") : text
+    )
+      .trim()
+      .slice(0, 100);
+    return includeUsage
+      ? llmProbeReceipt(target, { ok: true, reply, usage })
+      : reply;
   } catch (error) {
-    if (controller.signal.aborted)
-      throw new Error(`Connection test timed out after ${timeoutMs / 1000}s`);
-    throw error;
+    const failure = controller.signal.aborted
+      ? new Error(`Connection test timed out after ${timeoutMs / 1000}s`)
+      : error;
+    if (includeUsage) failure.probe = llmProbeReceipt(target, { usage });
+    throw failure;
   } finally {
     clearTimeout(timer);
   }

package/src/lib/llm-pricing.js

@@ -216,13 +216,18 @@ export function normalizePricingTerms(value) {
   const allowed = new Set([
     "cacheReadMultiplier",
     "cacheWriteMultiplier",
+    "cacheWrite1hMultiplier",
     "longContext",
     "serviceMultipliers",
   ]);
   if (!object(value) || Reflect.ownKeys(value).some((key) => !allowed.has(key)))
     fail();
   const result = {};
-  for (const key of ["cacheReadMultiplier", "cacheWriteMultiplier"]) {
+  for (const key of [
+    "cacheReadMultiplier",
+    "cacheWriteMultiplier",
+    "cacheWrite1hMultiplier",
+  ]) {
     if (!Object.hasOwn(value, key)) continue;
     if (!finite(value[key])) fail();
     result[key] = value[key];
@@ -289,8 +294,15 @@ export function lookupRate(provider, model, table = PRICE_TABLE) {
       // An unrecognized new generation must not inherit an older family price.
       // Explicit operator overrides remain authoritative.
       if (
-        ["opus", "sonnet"].includes(e.match) &&
-        Number(/^claude-(?:opus|sonnet)-(\d+)(?:[.-]|$)/u.exec(m)?.[1]) >= 5 &&
+        e.match === "haiku" &&
+        /(?:^|[.:/])(?:claude-)?haiku-(?:[5-9]|\d{2,})(?:[.-]|$)/u.test(m) &&
+        !e.explicitOverride
+      )
+        continue;
+      if (
+        ["opus", "sonnet", "haiku"].includes(e.match) &&
+        Number(/^claude-(?:opus|sonnet|haiku)-(\d+)(?:[.-]|$)/u.exec(m)?.[1]) >=
+          5 &&
         !e.explicitOverride
       )
         continue;
@@ -337,18 +349,42 @@ export function estimateCost({
   outputTokens = 0,
   cacheReadTokens = 0,
   cacheCreationTokens = 0,
+  cacheCreation5mTokens,
+  cacheCreation1hTokens,
+  cacheCreationInvalid = false,
+  pricingContextInvalid = false,
   requestInputTokens,
   serviceTier = "standard",
   regionalProcessing = false,
   table,
 } = {}) {
   const rate = lookupRate(provider, model, table);
+  const splitPresent =
+    cacheCreation5mTokens != null || cacheCreation1hTokens != null;
+  const splitValid =
+    splitPresent &&
+    Number.isSafeInteger(cacheCreation5mTokens) &&
+    cacheCreation5mTokens >= 0 &&
+    Number.isSafeInteger(cacheCreation1hTokens) &&
+    cacheCreation1hTokens >= 0 &&
+    cacheCreation5mTokens + cacheCreation1hTokens === cacheCreationTokens;
+  const missingCacheEvidence =
+    cacheCreationInvalid ||
+    (splitPresent && !splitValid) ||
+    (rate?.terms?.cacheWrite1hMultiplier != null &&
+      cacheCreationTokens > 0 &&
+      !splitValid);
   const tierMultiplier = rate?.terms?.serviceMultipliers
     ? Object.hasOwn(rate.terms.serviceMultipliers, serviceTier)
       ? rate.terms.serviceMultipliers[serviceTier]
       : null
     : 1;
-  if (!rate || tierMultiplier == null) {
+  if (
+    !rate ||
+    tierMultiplier == null ||
+    missingCacheEvidence ||
+    pricingContextInvalid
+  ) {
     return {
       inputCost: 0,
       outputCost: 0,
@@ -384,9 +420,14 @@ export function estimateCost({
     inputMultiplier *
     multiplier;
   const cacheCreationCost =
-    (Number(cacheCreationTokens) / 1e6) *
+    ((splitValid
+      ? cacheCreation5mTokens *
+          (rate.terms?.cacheWriteMultiplier ?? CACHE_WRITE_MULTIPLIER) +
+        cacheCreation1hTokens * (rate.terms?.cacheWrite1hMultiplier ?? 2)
+      : Number(cacheCreationTokens) *
+        (rate.terms?.cacheWriteMultiplier ?? CACHE_WRITE_MULTIPLIER)) /
+      1e6) *
     rate.in *
-    (rate.terms?.cacheWriteMultiplier ?? CACHE_WRITE_MULTIPLIER) *
     inputMultiplier *
     multiplier;
   return {
@@ -419,6 +460,15 @@ export function priceRollup(aggregate, { table } = {}) {
       outputTokens: row.outputTokens,
       cacheReadTokens: row.cacheReadTokens,
       cacheCreationTokens: row.cacheCreationTokens,
+      cacheCreation5mTokens: row.cacheCreation5mTokens,
+      cacheCreation1hTokens: row.cacheCreation1hTokens,
+      cacheCreationInvalid: row.cacheCreationInvalid,
+      pricingContextInvalid:
+        row.pricingContextInvalid === true ||
+        (String(row.provider).toLowerCase() === "anthropic" &&
+          String(row.model).toLowerCase() === "claude-haiku-5-5" &&
+          row.regionalProcessing == null &&
+          row.regional_processing == null),
       serviceTier: row.serviceTier ?? row.service_tier ?? "standard",
       regionalProcessing:
         row.regionalProcessing ?? row.regional_processing ?? false,
@@ -479,7 +529,11 @@ export function priceRollup(aggregate, { table } = {}) {
   for (const row of byModel) {
     if (row.matched) {
       totalCost += row.cost;
-    } else if (row.totalTokens > 0) {
+    } else if (
+      row.totalTokens > 0 ||
+      row.cacheReadTokens > 0 ||
+      row.cacheCreationTokens > 0
+    ) {
       unpriced.push({
         provider: row.provider,
         model: row.model,