@lucid-agents/pi-xgate 0.1.5 → 0.1.7

package/dist/taskmarket.js

@@ -0,0 +1,275 @@
+// Adapts TaskMarket's x402 payer to the xgate Pi transport. The payer package is private, so
+// this file declares the structural subset of its v1 contract (`@taskmarket/x402-payer`
+// `src/api.ts`, X402_PAYER_API_VERSION 1) that the adapter uses; TaskMarket injects its
+// instance. The payer owns the wallet, signer, rails, policy and journals: this adapter keeps
+// no payment state of its own.
+//
+// The payer's string unions may gain values without a version bump. Every type here accepts
+// unknown strings, and the adapter treats an unknown state as unverified.
+import { atomic, origin as checkOrigin, record, route as checkRoute, XgateError, } from "@lucid-agents/xgate-client/types";
+import { XgatePurchaseError, } from "./transport.js";
+const RESOLVED_CHARGES = ["none", "released", "settled", "manually_resolved"], RESOLVED_STATES = ["completed", "failed"];
+const CATALOG_BYTES = 2 * 1024 * 1024, REQUEST_BYTES = 8 * 1024 * 1024, CATALOG_DEADLINE_MS = 15000;
+/** Never sends the request again for an ID the payer has seen: `purchase` maps every non-verified outcome to a terminal error. */
+export function createTaskMarketTransport(options) {
+    const { payer } = options, base = checkOrigin(options.origin), fetcher = options.fetch ?? fetch;
+    if (payer.apiVersion !== 1)
+        throw new XgateError("unsupported_payer_api");
+    const channel = async (payment) => {
+        if (!options.balances || payment.rail.kind !== "session")
+            return;
+        try {
+            const matches = (await options.balances()).filter((b) => b.railId === payment.rail.id &&
+                b.network === payment.network &&
+                b.asset === payment.asset);
+            // Several sessions on one rail are not one channel; unlike balances are never summed.
+            if (matches.length !== 1)
+                return;
+            const b = matches[0];
+            return {
+                depositingAtomic: b.depositing,
+                lockedAtomic: b.locked,
+                chargedAtomic: b.charged,
+                pendingAtomic: b.pending,
+                refundableAtomic: b.refundable,
+            };
+        }
+        catch {
+            return; // Display only.
+        }
+    };
+    return {
+        async models(signal) {
+            const deadline = AbortSignal.timeout(CATALOG_DEADLINE_MS);
+            let response;
+            try {
+                response = await fetcher(base + "/v1/models", {
+                    signal: signal ? AbortSignal.any([signal, deadline]) : deadline,
+                    redirect: "error",
+                    cache: "no-store",
+                    credentials: "omit",
+                    referrerPolicy: "no-referrer",
+                    headers: { accept: "application/json" },
+                });
+            }
+            catch {
+                throw new XgateError("catalog_unavailable");
+            }
+            if (!response.ok) {
+                await response.body?.cancel().catch(() => { });
+                throw new XgateError("catalog_unavailable");
+            }
+            const v = parse(await bounded(response, CATALOG_BYTES));
+            if (!record(v) || !Array.isArray(v.data) || v.data.length > 128)
+                throw new XgateError("invalid_catalog");
+            return v.data
+                .filter((m) => record(m) &&
+                (options.models === undefined || options.models.includes(m.id)))
+                .map((m) => ({ ...m, xgate_origin: base }));
+        },
+        async purchase(invocation, signal, onResponse) {
+            checkRoute(invocation.route);
+            const body = new TextEncoder().encode(invocation.body);
+            if (body.byteLength === 0 || body.byteLength > REQUEST_BYTES)
+                throw new XgateError("invalid_invocation");
+            const id = invocation.id;
+            let result;
+            try {
+                result = await payer.request({
+                    apiVersion: 1,
+                    invocationId: id,
+                    url: base + invocation.route,
+                    method: "POST",
+                    // Application headers only: the payer owns every payment header.
+                    headers: {
+                        "content-type": "application/json",
+                        accept: "application/json",
+                    },
+                    body,
+                    limits: { maxRequestBodyBytes: REQUEST_BYTES },
+                    ...(options.allocationId !== undefined
+                        ? { allocationId: options.allocationId }
+                        : {}),
+                    ...(options.policyRuleId !== undefined
+                        ? { policyRuleId: options.policyRuleId }
+                        : {}),
+                    ...(options.nonInteractive !== undefined
+                        ? { nonInteractive: options.nonInteractive }
+                        : {}),
+                }, {
+                    ...(signal ? { signal } : {}),
+                    ...(options.confirmPayment
+                        ? { confirmPayment: options.confirmPayment }
+                        : {}),
+                });
+            }
+            catch (error) {
+                throw failure(error, id);
+            }
+            const payment = result.payment;
+            if (result.invocationId !== id || result.apiVersion !== 1)
+                throw new XgatePurchaseError("payer_result_mismatch", id, true, payment && display(payment));
+            // A paid xgate route never answers without a payment challenge.
+            if (!payment)
+                throw new XgatePurchaseError(result.response.status === 200
+                    ? "payment_missing"
+                    : "request_rejected", id, false);
+            const shown = display(payment);
+            if (payment.charge !== "settled" ||
+                typeof payment.settledAmount !== "string")
+                throw new XgatePurchaseError("payment_unverified", id, true, shown);
+            shown.chargedAtomic = payment.settledAmount;
+            try {
+                if (atomic(payment.settledAmount) > atomic(payment.authorizedAmount))
+                    throw new XgateError("charge_over_authorization");
+            }
+            catch {
+                throw new XgatePurchaseError("invalid_settlement", id, true, shown);
+            }
+            const r = result.response, h = r.headers;
+            // Charged, so not pending, but the content is unusable.
+            if (r.status !== 200 ||
+                !/^application\/json\b/i.test(r.contentType) ||
+                h["x-inference-privacy"] !== "anonymous" ||
+                h["x-result-retention"] !== "none" ||
+                !h["cache-control"]?.includes("no-store"))
+                throw new XgatePurchaseError("response_rejected", id, false, shown);
+            let value;
+            try {
+                value = parse(r.body);
+            }
+            catch {
+                throw new XgatePurchaseError("invalid_response", id, false, shown);
+            }
+            if (!record(value) ||
+                typeof value.id !== "string" ||
+                value.result_replay_available !== undefined)
+                throw new XgatePurchaseError("invalid_response", id, false, shown);
+            const head = {
+                status: r.status,
+                headers: { "content-type": r.contentType, "cache-control": "no-store" },
+            };
+            try {
+                await onResponse?.(head);
+            }
+            catch {
+                throw new XgatePurchaseError("response_hook_failed", id, false, shown);
+            }
+            const balance = await channel(payment);
+            if (balance)
+                shown.channel = balance;
+            return {
+                body: value,
+                settlement: {
+                    chargedAtomic: payment.settledAmount,
+                    reference: payment.transaction ?? payment.commitment ?? payment.paymentId,
+                },
+                purchase: payment.commitment ?? payment.paymentId,
+                payment: shown,
+            };
+        },
+        async status() {
+            return {
+                transport: "taskmarket",
+                origin: base,
+                ...(options.balances
+                    ? {
+                        balances: (await options.balances()).map((b) => ({
+                            rail: b.railId,
+                            network: b.network,
+                            asset: b.asset,
+                            depositingAtomic: b.depositing,
+                            lockedAtomic: b.locked,
+                            chargedAtomic: b.charged,
+                            pendingAtomic: b.pending,
+                            refundableAtomic: b.refundable,
+                        })),
+                    }
+                    : {}),
+            };
+        },
+        async reconcile(invocationId) {
+            const s = await payer.reconcile(invocationId);
+            return {
+                invocationId: s.invocationId,
+                state: s.state,
+                charge: s.charge,
+                uncertain: s.uncertain,
+                ...(s.errorCode ? { errorCode: s.errorCode } : {}),
+                ...(s.payment ? { payment: display(s.payment) } : {}),
+            };
+        },
+    };
+}
+function display(p) {
+    return {
+        network: p.network,
+        scheme: p.scheme,
+        asset: p.asset,
+        payTo: p.payTo,
+        rail: p.rail.kind,
+        authorizedAtomic: p.authorizedAmount,
+        ...(p.charge === "settled" && p.settledAmount !== undefined
+            ? { chargedAtomic: p.settledAmount }
+            : {}),
+        status: p.charge,
+        ...((p.transaction ?? p.commitment)
+            ? { reference: p.transaction ?? p.commitment }
+            : {}),
+    };
+}
+/**
+ * Maps a payer rejection. Only the stable code crosses into Pi; the payer's message may carry
+ * URLs or server text. A rejection that does not state `pending: false` counts as pending.
+ */
+function failure(error, id) {
+    const e = error;
+    const code = typeof e?.code === "string" && /^[a-z0-9_]{1,64}$/.test(e.code)
+        ? e.code
+        : "payer_failed";
+    // A duplicate never sends again, but its recorded invocation may still be unresolved: only a
+    // positively resolved record counts as not pending.
+    const recorded = e?.invocation;
+    const pending = e?.pending !== false ||
+        (recorded !== undefined &&
+            !(recorded.uncertain === false &&
+                RESOLVED_CHARGES.includes(recorded.charge) &&
+                RESOLVED_STATES.includes(recorded.state)));
+    const summary = e?.invocation?.payment;
+    return new XgatePurchaseError(code, id, pending, record(summary) ? display(summary) : undefined);
+}
+async function bounded(response, limit) {
+    if (!response.body)
+        throw new XgateError("invalid_catalog");
+    const reader = response.body.getReader(), chunks = [];
+    let length = 0;
+    try {
+        for (;;) {
+            const part = await reader.read();
+            if (part.done)
+                break;
+            length += part.value.byteLength;
+            if (length > limit)
+                throw new XgateError("catalog_bound");
+            chunks.push(part.value);
+        }
+    }
+    catch (error) {
+        await reader.cancel().catch(() => { });
+        throw error instanceof XgateError
+            ? error
+            : new XgateError("catalog_unavailable");
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks, length);
+}
+function parse(bytes) {
+    try {
+        return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new XgateError("invalid_response");
+    }
+}

package/dist/transport.d.ts

@@ -0,0 +1,72 @@
+import { XgateError, type Invocation, type PurchaseResult } from "@lucid-agents/xgate-client/types";
+/** Response metadata safe to show Pi's `onResponse` hook: never payment or status credentials. */
+export interface XgateResponseHead {
+    status: number;
+    headers: Record<string, string>;
+}
+/**
+ * Rail-neutral payment terms and status for display. Pi shows them; it never selects or
+ * configures a rail. Amounts are unsigned integer strings in the asset's smallest unit, and
+ * amounts of different assets are never combined.
+ */
+export interface XgatePayment {
+    /** CAIP-2 network, e.g. `eip155:8453`. */
+    network: string;
+    /** Payment scheme as the payee advertised it, e.g. `batch-settlement`, `exact`, `session`. */
+    scheme: string;
+    asset: string;
+    payTo?: string;
+    /** Rail shape: `per-request` or `session` today; other values may appear. */
+    rail?: string;
+    /** Most this invocation could be charged. */
+    authorizedAtomic: string;
+    /** Verified charge, once known. */
+    chargedAtomic?: string;
+    /** `settled`, `pending`, `amount_unknown`, `released`, ...; anything but `settled` is unverified. */
+    status: string;
+    /** Settlement transaction or payee commitment, when one exists. */
+    reference?: string;
+    /** Session-rail balance after this payment, when the host reports one. */
+    channel?: XgateChannelBalance;
+}
+export interface XgateChannelBalance {
+    depositingAtomic: string;
+    lockedAtomic: string;
+    chargedAtomic: string;
+    pendingAtomic: string;
+    refundableAtomic: string;
+}
+export interface XgatePurchaseResult extends PurchaseResult {
+    payment?: XgatePayment;
+}
+/**
+ * A purchase that ended without a verified result. `pending` is true when money may have moved
+ * and the outcome is unknown: the invocation must be reconciled, never retried.
+ */
+export declare class XgatePurchaseError extends XgateError {
+    readonly invocationId: string;
+    readonly pending: boolean;
+    readonly payment?: XgatePayment;
+    constructor(code: string, invocationId: string, pending: boolean, payment?: XgatePayment);
+}
+/**
+ * Moves one frozen Pi request to xgate and returns the verified result. The provider owns
+ * catalog qualification, codecs and the invocation ID; the transport owns payment.
+ *
+ * `purchase` sends at most one paid submission per `Invocation.id`, never retries a paid
+ * request, and never pays again for an ID it has seen: a repeated ID rejects. It resolves
+ * only with a verified result and rejects on every other outcome, preferably with an
+ * `XgatePurchaseError` stating whether the payment is pending. `BrokerClient` is the
+ * standalone implementation.
+ */
+export interface XgateTransport {
+    /** Current router catalog rows. Called before every paid invocation. */
+    models(signal?: AbortSignal): Promise<unknown[]>;
+    purchase(invocation: Invocation, signal?: AbortSignal, onResponse?: (response: XgateResponseHead) => Promise<void>): Promise<XgatePurchaseResult>;
+    /** Optional `/xgate status` and `/xgate budget` view. */
+    status?(signal?: AbortSignal): Promise<unknown>;
+    /** Optional `/xgate receipts` view. */
+    receipts?(signal?: AbortSignal): Promise<unknown>;
+    /** Optional `/xgate reconcile <invocation ID>`. Never resends the request. */
+    reconcile?(invocationId: string, signal?: AbortSignal): Promise<unknown>;
+}

package/dist/transport.js

@@ -0,0 +1,21 @@
+import { XgateError, } from "@lucid-agents/xgate-client/types";
+/**
+ * A purchase that ended without a verified result. `pending` is true when money may have moved
+ * and the outcome is unknown: the invocation must be reconciled, never retried.
+ */
+export class XgatePurchaseError extends XgateError {
+    invocationId;
+    pending;
+    payment;
+    constructor(code, invocationId, pending, payment) {
+        super(code);
+        this.name = "XgatePurchaseError";
+        this.message = pending
+            ? `Xgate: ${code}. The payment outcome is unknown; do not retry. Reconcile it before another purchase.`
+            : `Xgate: ${code}. Inspect the payment status before another purchase.`;
+        this.invocationId = invocationId;
+        this.pending = pending;
+        if (payment)
+            this.payment = payment;
+    }
+}

package/package.json

@@ -1,7 +1,18 @@
 {
   "name": "@lucid-agents/pi-xgate",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./extension": {
+      "types": "./dist/extension.d.ts",
+      "default": "./dist/extension.js"
+    },
+    "./package.json": "./package.json"
+  },
   "keywords": [
     "pi-package",
     "xgate",
@@ -15,19 +26,20 @@
     ]
   },
   "files": [
+    "dist",
     "src",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@lucid-agents/xgate-client": "0.1.5"
+    "@lucid-agents/xgate-client": "0.1.7"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "1.1.0",
-    "@earendil-works/pi-coding-agent": "1.1.0"
+    "@earendil-works/pi-ai": "0.85.1 || 1.1.0",
+    "@earendil-works/pi-coding-agent": "0.85.1 || 1.1.0"
   },
   "engines": {
-    "node": ">=24.19 <25"
+    "node": ">=24.19"
   },
   "description": "Wallet-paid OpenAI and Anthropic inference through xgate for the Pi coding agent",
   "repository": {
@@ -44,10 +56,10 @@
     "registry": "https://registry.npmjs.org"
   },
   "license": "MIT",
-  "gitHead": "2c12308686701f39f95093c5984d014c0ec83d26",
+  "gitHead": "90a64abcca7028250d4092c42b37a9d627bde8fe",
   "xgateRelease": {
-    "version": "v0.1.5",
-    "sourceSha": "2c12308686701f39f95093c5984d014c0ec83d26",
-    "candidateId": "rc-2c1230868670-37853927676-1"
+    "version": "v0.1.7",
+    "sourceSha": "90a64abcca7028250d4092c42b37a9d627bde8fe",
+    "candidateId": "rc-90a64abcca70-38543861426-1"
   }
 }

package/src/codec.ts

@@ -1,22 +1,39 @@
-import {
-  collapseSystemMessages,
-  getCurrentSystemPrompt,
-  getCurrentTools,
-  type AssistantMessage,
-  type Model,
-  type SimpleStreamOptions,
-  type TranscriptContext,
-  type Usage,
-  type ThinkingLevelMap,
+import * as pi from "@earendil-works/pi-ai";
+import type {
+  AssistantMessage,
+  Context,
+  Message,
+  Model,
+  SimpleStreamOptions,
+  Tool,
+  TranscriptContext,
+  Usage,
+  ThinkingLevelMap,
 } from "@earendil-works/pi-ai";
 import { XgateError, type Route } from "@lucid-agents/xgate-client/types";
 import capabilities from "./generated/openai-model-capabilities.json" with { type: "json" };
 import { createHash } from "node:crypto";
+/** The widest Anthropic prompt-cache write lifetime a scope's qualification permits. */
+export type CacheTtl = "none" | "5m" | "1h";
 export type Entry = {
   model: Model<any>;
   catalog: any;
   route: Route;
   efforts: string[];
+  /** Anthropic only: requests may carry `cache_control` breakpoints up to this lifetime. */
+  cache: CacheTtl;
+  /** Anthropic only: the per-million-token price of a one-hour cache write. */
+  cacheWrite1h: number;
+};
+/**
+ * The router quotes the class a request's `cache_control` markers select, and serves it only
+ * when the scope's qualification covers that class. A wider qualification covers narrower
+ * requests, so a cache-qualified scope still serves a request without markers.
+ */
+const ANTHROPIC_CACHE: Record<string, CacheTtl> = {
+  anthropic_no_cache: "none",
+  anthropic_ephemeral_5m: "5m",
+  anthropic_ephemeral_1h: "1h",
 };
 const need = (x: unknown, code: string): void => {
   if (!x) throw new XgateError(code);
@@ -69,7 +86,7 @@ export function catalogEntries(rows: any[]): Entry[] {
       !q ||
       row.privacy?.revision !== "anonymous-volatile-v1" ||
       row.privacy.result_replay_available !== false ||
-      (anthropic && q.cache_mode !== "anthropic_no_cache")
+      (anthropic && !Object.hasOwn(ANTHROPIC_CACHE, q.cache_mode))
     )
       continue;
     if (
@@ -122,8 +139,13 @@ export function catalogEntries(rows: any[]): Entry[] {
           ["minimal", "low", "medium", "high"].includes(level));
       thinkingLevelMap[level] = allowed ? level : null;
     }
+    const write5m = p.rates.input_cache_write_5m ?? p.rates.input_cache_write;
     entries.push({
       catalog: row,
+      cache: anthropic ? ANTHROPIC_CACHE[q.cache_mode]! : "none",
+      cacheWrite1h: p.rates.input_cache_write_1h
+        ? rate(p.rates.input_cache_write_1h)
+        : 0,
       route: anthropic
         ? "/providers/anthropic/v1/messages"
         : "/providers/openai/v1/responses",
@@ -145,9 +167,7 @@ export function catalogEntries(rows: any[]): Entry[] {
           input: rate(p.rates.input_uncached),
           output: rate(p.rates.output),
           cacheRead: rate(p.rates.input_cache_read),
-          cacheWrite: p.rates.input_cache_write
-            ? rate(p.rates.input_cache_write)
-            : 0,
+          cacheWrite: write5m ? rate(write5m) : 0,
         },
         inputLimits: { maxRequestBytes: 8 * 1024 * 1024 },
       },
@@ -155,6 +175,45 @@ export function catalogEntries(rows: any[]): Entry[] {
   }
   return entries;
 }
+/**
+ * Pi 1.1 passes a normalized transcript; Pi 0.85 passes `systemPrompt` and `tools` beside the
+ * messages. Structural, so published types do not name a type only one Pi version has.
+ */
+export type PiContext = {
+  messages: Message[];
+  systemPrompt?: string;
+  tools?: Tool[];
+};
+type Turn = Exclude<Message, { role: "system" }>;
+export function transcript(context: PiContext): {
+  system: string;
+  tools: Tool[];
+  messages: Turn[];
+} {
+  const legacy = "systemPrompt" in context || "tools" in context;
+  if (typeof pi.collapseSystemMessages !== "function") {
+    need(
+      !context.messages.some((m) => m.role === "system"),
+      "unsupported_context",
+    );
+    const raw = context as Context;
+    return {
+      system: raw.systemPrompt ?? "",
+      tools: raw.tools ?? [],
+      messages: raw.messages as Turn[],
+    };
+  }
+  const collapsed = pi.collapseSystemMessages(
+    legacy
+      ? pi.normalizeContext(context as Context)
+      : (context as TranscriptContext),
+  );
+  return {
+    system: pi.getCurrentSystemPrompt(collapsed.messages),
+    tools: pi.getCurrentTools(collapsed.messages),
+    messages: collapsed.messages.filter((m): m is Turn => m.role !== "system"),
+  };
+}
 function text(content: any): string {
   if (typeof content === "string") return content;
   need(
@@ -187,7 +246,7 @@ function validateTools(tools: any[], anthropic: boolean): void {
 }
 export function encode(
   entry: Entry,
-  context: TranscriptContext,
+  context: PiContext,
   options: SimpleStreamOptions = {},
 ): any {
   need(
@@ -205,9 +264,7 @@ export function encode(
     "unsupported_sampling",
   );
   const anthropic = entry.route.endsWith("/messages"),
-    collapsed = collapseSystemMessages(context),
-    system = getCurrentSystemPrompt(collapsed.messages),
-    tools = getCurrentTools(collapsed.messages);
+    { system, tools, messages } = transcript(context);
   validateTools(tools, anthropic);
   const max = options.maxTokens ?? Math.min(4096, entry.model.maxTokens);
   need(
@@ -234,8 +291,7 @@ export function encode(
     else history.push({ role, content });
   };
   if (!anthropic && system) history.push({ role: "system", content: system });
-  for (const message of collapsed.messages) {
-    if (message.role === "system") continue;
+  for (const message of messages) {
     if (message.role === "user") {
       const value = text(message.content);
       if (anthropic) append("user", [{ type: "text", text: value }]);
@@ -360,23 +416,39 @@ export function encode(
   need(history.length > 0 && history.length <= 256, "history_limit");
   let request: any;
   if (anthropic) {
-    const cap = entry.catalog.execution_profile.capabilities;
+    const cap = entry.catalog.execution_profile.capabilities,
+      cache = cacheControl(entry.cache, options.cacheRetention);
     request = {
       model: entry.model.id,
       messages: history,
       max_tokens: max,
       stream: false,
-      ...(system ? { system } : {}),
+      ...(system
+        ? {
+            system: cache
+              ? [{ type: "text", text: system, cache_control: cache }]
+              : system,
+          }
+        : {}),
       ...(tools.length
         ? {
-            tools: tools.map((t) => ({
+            tools: tools.map((t, i) => ({
               name: t.name,
               description: t.description,
               input_schema: t.parameters,
+              ...(cache && i === tools.length - 1
+                ? { cache_control: cache }
+                : {}),
             })),
           }
         : {}),
     };
+    // Anthropic caches nothing without a breakpoint. Like Pi's direct Anthropic provider, mark
+    // the tools, the system prompt and the newest turn: the next request in the conversation
+    // reads the whole previous prefix. A final user turn ends in text or a tool result.
+    const last = history.at(-1);
+    if (cache && last.role === "user")
+      last.content.at(-1).cache_control = cache;
     if (effort) request.output_config = { effort };
     if (cap.thinking.adaptive) request.thinking = { type: "adaptive" };
     else if (requested && cap.thinking.enabled) {
@@ -419,6 +491,15 @@ export function encode(
   );
   return request;
 }
+function cacheControl(
+  qualified: CacheTtl,
+  retention: SimpleStreamOptions["cacheRetention"],
+): { type: "ephemeral"; ttl?: "1h" } | undefined {
+  if (qualified === "none" || retention === "none") return undefined;
+  return retention === "long" && qualified === "1h"
+    ? { type: "ephemeral", ttl: "1h" }
+    : { type: "ephemeral" };
+}
 function tokens(value: any): number {
   need(Number.isSafeInteger(value) && value >= 0, "invalid_usage");
   return value;
@@ -591,9 +672,17 @@ export function decode(
     ),
     totalInput = tokens(u.input_tokens),
     output = tokens(u.output_tokens),
-    input = anthropic ? totalInput : totalInput - read - write;
+    input = anthropic ? totalInput : totalInput - read - write,
+    // Anthropic splits writes by lifetime; an unsplit write is the default five minutes.
+    write1h =
+      anthropic && object(u.cache_creation)
+        ? tokens(u.cache_creation.ephemeral_1h_input_tokens ?? 0)
+        : 0;
   need(
-    input >= 0 && (!anthropic || (read === 0 && write === 0)),
+    input >= 0 &&
+      write1h <= write &&
+      (!anthropic || entry.cache !== "none" || (read === 0 && write === 0)) &&
+      (!anthropic || entry.cache === "1h" || write1h === 0),
     "cache_usage_mismatch",
   );
   const rates = entry.model.cost;
@@ -601,7 +690,9 @@ export function decode(
     input: (input * rates.input) / 1e6,
     output: (output * rates.output) / 1e6,
     cacheRead: (read * rates.cacheRead) / 1e6,
-    cacheWrite: (write * rates.cacheWrite) / 1e6,
+    cacheWrite:
+      ((write - write1h) * rates.cacheWrite + write1h * entry.cacheWrite1h) /
+      1e6,
     total: 0,
   };
   cost.total = cost.input + cost.output + cost.cacheRead + cost.cacheWrite;